Merge branch 'master' into amd-common
[deliverable/binutils-gdb.git] / binutils / readelf.c
1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2020 Free Software Foundation, Inc.
3 Copyright (C) 2019 Advanced Micro Devices, Inc. All rights reserved.
4
5 Originally developed by Eric Youngdale <eric@andante.jic.com>
6 Modifications by Nick Clifton <nickc@redhat.com>
7
8 This file is part of GNU Binutils.
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
23 02110-1301, USA. */
24 \f
25 /* The difference between readelf and objdump:
26
27 Both programs are capable of displaying the contents of ELF format files,
28 so why does the binutils project have two file dumpers ?
29
30 The reason is that objdump sees an ELF file through a BFD filter of the
31 world; if BFD has a bug where, say, it disagrees about a machine constant
32 in e_flags, then the odds are good that it will remain internally
33 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
34 GAS sees it the BFD way. There was need for a tool to go find out what
35 the file actually says.
36
37 This is why the readelf program does not link against the BFD library - it
38 exists as an independent program to help verify the correct working of BFD.
39
40 There is also the case that readelf can provide more information about an
41 ELF file than is provided by objdump. In particular it can display DWARF
42 debugging information which (at the moment) objdump cannot. */
43 \f
44 #include "sysdep.h"
45 #include <assert.h>
46 #include <time.h>
47 #include <zlib.h>
48 #ifdef HAVE_WCHAR_H
49 #include <wchar.h>
50 #endif
51
52 #if __GNUC__ >= 2
53 /* Define BFD64 here, even if our default architecture is 32 bit ELF
54 as this will allow us to read in and parse 64bit and 32bit ELF files.
55 Only do this if we believe that the compiler can support a 64 bit
56 data type. For now we only rely on GCC being able to do this. */
57 #define BFD64
58 #endif
59
60 #include "bfd.h"
61 #include "bucomm.h"
62 #include "elfcomm.h"
63 #include "dwarf.h"
64 #include "ctf-api.h"
65
66 #include "elf/common.h"
67 #include "elf/external.h"
68 #include "elf/internal.h"
69
70
71 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
72 we can obtain the H8 reloc numbers. We need these for the
73 get_reloc_size() function. We include h8.h again after defining
74 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
75
76 #include "elf/h8.h"
77 #undef _ELF_H8_H
78
79 /* Undo the effects of #including reloc-macros.h. */
80
81 #undef START_RELOC_NUMBERS
82 #undef RELOC_NUMBER
83 #undef FAKE_RELOC
84 #undef EMPTY_RELOC
85 #undef END_RELOC_NUMBERS
86 #undef _RELOC_MACROS_H
87
88 /* The following headers use the elf/reloc-macros.h file to
89 automatically generate relocation recognition functions
90 such as elf_mips_reloc_type() */
91
92 #define RELOC_MACROS_GEN_FUNC
93
94 #include "elf/aarch64.h"
95 #include "elf/alpha.h"
96 #include "elf/amdgcn.h"
97 #include "elf/arc.h"
98 #include "elf/arm.h"
99 #include "elf/avr.h"
100 #include "elf/bfin.h"
101 #include "elf/cr16.h"
102 #include "elf/cris.h"
103 #include "elf/crx.h"
104 #include "elf/csky.h"
105 #include "elf/d10v.h"
106 #include "elf/d30v.h"
107 #include "elf/dlx.h"
108 #include "elf/bpf.h"
109 #include "elf/epiphany.h"
110 #include "elf/fr30.h"
111 #include "elf/frv.h"
112 #include "elf/ft32.h"
113 #include "elf/h8.h"
114 #include "elf/hppa.h"
115 #include "elf/i386.h"
116 #include "elf/i370.h"
117 #include "elf/i860.h"
118 #include "elf/i960.h"
119 #include "elf/ia64.h"
120 #include "elf/ip2k.h"
121 #include "elf/lm32.h"
122 #include "elf/iq2000.h"
123 #include "elf/m32c.h"
124 #include "elf/m32r.h"
125 #include "elf/m68k.h"
126 #include "elf/m68hc11.h"
127 #include "elf/s12z.h"
128 #include "elf/mcore.h"
129 #include "elf/mep.h"
130 #include "elf/metag.h"
131 #include "elf/microblaze.h"
132 #include "elf/mips.h"
133 #include "elf/mmix.h"
134 #include "elf/mn10200.h"
135 #include "elf/mn10300.h"
136 #include "elf/moxie.h"
137 #include "elf/mt.h"
138 #include "elf/msp430.h"
139 #include "elf/nds32.h"
140 #include "elf/nfp.h"
141 #include "elf/nios2.h"
142 #include "elf/or1k.h"
143 #include "elf/pj.h"
144 #include "elf/ppc.h"
145 #include "elf/ppc64.h"
146 #include "elf/pru.h"
147 #include "elf/riscv.h"
148 #include "elf/rl78.h"
149 #include "elf/rx.h"
150 #include "elf/s390.h"
151 #include "elf/score.h"
152 #include "elf/sh.h"
153 #include "elf/sparc.h"
154 #include "elf/spu.h"
155 #include "elf/tic6x.h"
156 #include "elf/tilegx.h"
157 #include "elf/tilepro.h"
158 #include "elf/v850.h"
159 #include "elf/vax.h"
160 #include "elf/visium.h"
161 #include "elf/wasm32.h"
162 #include "elf/x86-64.h"
163 #include "elf/xc16x.h"
164 #include "elf/xgate.h"
165 #include "elf/xstormy16.h"
166 #include "elf/xtensa.h"
167
168 #include "getopt.h"
169 #include "libiberty.h"
170 #include "safe-ctype.h"
171 #include "filenames.h"
172
173 #ifndef offsetof
174 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
175 #endif
176
177 typedef struct elf_section_list
178 {
179 Elf_Internal_Shdr * hdr;
180 struct elf_section_list * next;
181 } elf_section_list;
182
183 /* Flag bits indicating particular types of dump. */
184 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
185 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
186 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
187 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
188 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
189 #define CTF_DUMP (1 << 5) /* The --ctf command line switch. */
190
191 typedef unsigned char dump_type;
192
193 /* A linked list of the section names for which dumps were requested. */
194 struct dump_list_entry
195 {
196 char * name;
197 dump_type type;
198 struct dump_list_entry * next;
199 };
200
201 typedef struct filedata
202 {
203 const char * file_name;
204 FILE * handle;
205 bfd_size_type file_size;
206 Elf_Internal_Ehdr file_header;
207 Elf_Internal_Shdr * section_headers;
208 Elf_Internal_Phdr * program_headers;
209 char * string_table;
210 unsigned long string_table_length;
211 /* A dynamic array of flags indicating for which sections a dump of
212 some kind has been requested. It is reset on a per-object file
213 basis and then initialised from the cmdline_dump_sects array,
214 the results of interpreting the -w switch, and the
215 dump_sects_byname list. */
216 dump_type * dump_sects;
217 unsigned int num_dump_sects;
218 } Filedata;
219
220 char * program_name = "readelf";
221
222 static unsigned long archive_file_offset;
223 static unsigned long archive_file_size;
224 static unsigned long dynamic_addr;
225 static bfd_size_type dynamic_size;
226 static size_t dynamic_nent;
227 static char * dynamic_strings;
228 static unsigned long dynamic_strings_length;
229 static unsigned long num_dynamic_syms;
230 static Elf_Internal_Sym * dynamic_symbols;
231 static Elf_Internal_Syminfo * dynamic_syminfo;
232 static unsigned long dynamic_syminfo_offset;
233 static unsigned int dynamic_syminfo_nent;
234 static char program_interpreter[PATH_MAX];
235 static bfd_vma dynamic_info[DT_ENCODING];
236 static bfd_vma dynamic_info_DT_GNU_HASH;
237 static bfd_vma dynamic_info_DT_MIPS_XHASH;
238 static bfd_vma version_info[16];
239 static Elf_Internal_Dyn * dynamic_section;
240 static elf_section_list * symtab_shndx_list;
241 static bfd_boolean show_name = FALSE;
242 static bfd_boolean do_dynamic = FALSE;
243 static bfd_boolean do_syms = FALSE;
244 static bfd_boolean do_dyn_syms = FALSE;
245 static bfd_boolean do_reloc = FALSE;
246 static bfd_boolean do_sections = FALSE;
247 static bfd_boolean do_section_groups = FALSE;
248 static bfd_boolean do_section_details = FALSE;
249 static bfd_boolean do_segments = FALSE;
250 static bfd_boolean do_unwind = FALSE;
251 static bfd_boolean do_using_dynamic = FALSE;
252 static bfd_boolean do_header = FALSE;
253 static bfd_boolean do_dump = FALSE;
254 static bfd_boolean do_version = FALSE;
255 static bfd_boolean do_histogram = FALSE;
256 static bfd_boolean do_debugging = FALSE;
257 static bfd_boolean do_ctf = FALSE;
258 static bfd_boolean do_arch = FALSE;
259 static bfd_boolean do_notes = FALSE;
260 static bfd_boolean do_archive_index = FALSE;
261 static bfd_boolean is_32bit_elf = FALSE;
262 static bfd_boolean decompress_dumps = FALSE;
263
264 static char *dump_ctf_parent_name;
265 static char *dump_ctf_symtab_name;
266 static char *dump_ctf_strtab_name;
267
268 struct group_list
269 {
270 struct group_list * next;
271 unsigned int section_index;
272 };
273
274 struct group
275 {
276 struct group_list * root;
277 unsigned int group_index;
278 };
279
280 static size_t group_count;
281 static struct group * section_groups;
282 static struct group ** section_headers_groups;
283
284 /* A dynamic array of flags indicating for which sections a dump
285 has been requested via command line switches. */
286 static Filedata cmdline;
287
288 static struct dump_list_entry * dump_sects_byname;
289
290 /* How to print a vma value. */
291 typedef enum print_mode
292 {
293 HEX,
294 DEC,
295 DEC_5,
296 UNSIGNED,
297 PREFIX_HEX,
298 FULL_HEX,
299 LONG_HEX
300 }
301 print_mode;
302
303 /* Versioned symbol info. */
304 enum versioned_symbol_info
305 {
306 symbol_undefined,
307 symbol_hidden,
308 symbol_public
309 };
310
311 static const char * get_symbol_version_string
312 (Filedata *, bfd_boolean, const char *, unsigned long, unsigned,
313 Elf_Internal_Sym *, enum versioned_symbol_info *, unsigned short *);
314
315 #define UNKNOWN -1
316
317 #define SECTION_NAME(X) \
318 ((X) == NULL ? _("<none>") \
319 : filedata->string_table == NULL ? _("<no-strings>") \
320 : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>") \
321 : filedata->string_table + (X)->sh_name))
322
323 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
324
325 #define GET_ELF_SYMBOLS(file, section, sym_count) \
326 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
327 : get_64bit_elf_symbols (file, section, sym_count))
328
329 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
330 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
331 already been called and verified that the string exists. */
332 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
333
334 #define REMOVE_ARCH_BITS(ADDR) \
335 do \
336 { \
337 if (filedata->file_header.e_machine == EM_ARM) \
338 (ADDR) &= ~1; \
339 } \
340 while (0)
341
342 /* Get the correct GNU hash section name. */
343 #define GNU_HASH_SECTION_NAME \
344 dynamic_info_DT_MIPS_XHASH ? ".MIPS.xhash" : ".gnu.hash"
345 \f
346 /* Print a BFD_VMA to an internal buffer, for use in error messages.
347 BFD_FMA_FMT can't be used in translated strings. */
348
349 static const char *
350 bfd_vmatoa (char *fmtch, bfd_vma value)
351 {
352 /* bfd_vmatoa is used more then once in a printf call for output.
353 Cycle through an array of buffers. */
354 static int buf_pos = 0;
355 static struct bfd_vmatoa_buf
356 {
357 char place[64];
358 } buf[4];
359 char *ret;
360 char fmt[32];
361
362 ret = buf[buf_pos++].place;
363 buf_pos %= ARRAY_SIZE (buf);
364
365 sprintf (fmt, "%%%s%s", BFD_VMA_FMT, fmtch);
366 snprintf (ret, sizeof (buf[0].place), fmt, value);
367 return ret;
368 }
369
370 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
371 OFFSET + the offset of the current archive member, if we are examining an
372 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
373 allocate a buffer using malloc and fill that. In either case return the
374 pointer to the start of the retrieved data or NULL if something went wrong.
375 If something does go wrong and REASON is not NULL then emit an error
376 message using REASON as part of the context. */
377
378 static void *
379 get_data (void * var,
380 Filedata * filedata,
381 unsigned long offset,
382 bfd_size_type size,
383 bfd_size_type nmemb,
384 const char * reason)
385 {
386 void * mvar;
387 bfd_size_type amt = size * nmemb;
388
389 if (size == 0 || nmemb == 0)
390 return NULL;
391
392 /* If the size_t type is smaller than the bfd_size_type, eg because
393 you are building a 32-bit tool on a 64-bit host, then make sure
394 that when the sizes are cast to (size_t) no information is lost. */
395 if ((size_t) size != size
396 || (size_t) nmemb != nmemb
397 || (size_t) amt != amt)
398 {
399 if (reason)
400 error (_("Size truncation prevents reading %s"
401 " elements of size %s for %s\n"),
402 bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
403 return NULL;
404 }
405
406 /* Check for size overflow. */
407 if (amt / size != nmemb || (size_t) amt + 1 == 0)
408 {
409 if (reason)
410 error (_("Size overflow prevents reading %s"
411 " elements of size %s for %s\n"),
412 bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
413 return NULL;
414 }
415
416 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
417 attempting to allocate memory when the read is bound to fail. */
418 if (archive_file_offset > filedata->file_size
419 || offset > filedata->file_size - archive_file_offset
420 || amt > filedata->file_size - archive_file_offset - offset)
421 {
422 if (reason)
423 error (_("Reading %s bytes extends past end of file for %s\n"),
424 bfd_vmatoa ("u", amt), reason);
425 return NULL;
426 }
427
428 if (fseek (filedata->handle, archive_file_offset + offset, SEEK_SET))
429 {
430 if (reason)
431 error (_("Unable to seek to 0x%lx for %s\n"),
432 archive_file_offset + offset, reason);
433 return NULL;
434 }
435
436 mvar = var;
437 if (mvar == NULL)
438 {
439 /* + 1 so that we can '\0' terminate invalid string table sections. */
440 mvar = malloc ((size_t) amt + 1);
441
442 if (mvar == NULL)
443 {
444 if (reason)
445 error (_("Out of memory allocating %s bytes for %s\n"),
446 bfd_vmatoa ("u", amt), reason);
447 return NULL;
448 }
449
450 ((char *) mvar)[amt] = '\0';
451 }
452
453 if (fread (mvar, (size_t) size, (size_t) nmemb, filedata->handle) != nmemb)
454 {
455 if (reason)
456 error (_("Unable to read in %s bytes of %s\n"),
457 bfd_vmatoa ("u", amt), reason);
458 if (mvar != var)
459 free (mvar);
460 return NULL;
461 }
462
463 return mvar;
464 }
465
466 /* Print a VMA value in the MODE specified.
467 Returns the number of characters displayed. */
468
469 static unsigned int
470 print_vma (bfd_vma vma, print_mode mode)
471 {
472 unsigned int nc = 0;
473
474 switch (mode)
475 {
476 case FULL_HEX:
477 nc = printf ("0x");
478 /* Fall through. */
479 case LONG_HEX:
480 #ifdef BFD64
481 if (is_32bit_elf)
482 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
483 #endif
484 printf_vma (vma);
485 return nc + 16;
486
487 case DEC_5:
488 if (vma <= 99999)
489 return printf ("%5" BFD_VMA_FMT "d", vma);
490 /* Fall through. */
491 case PREFIX_HEX:
492 nc = printf ("0x");
493 /* Fall through. */
494 case HEX:
495 return nc + printf ("%" BFD_VMA_FMT "x", vma);
496
497 case DEC:
498 return printf ("%" BFD_VMA_FMT "d", vma);
499
500 case UNSIGNED:
501 return printf ("%" BFD_VMA_FMT "u", vma);
502
503 default:
504 /* FIXME: Report unrecognised mode ? */
505 return 0;
506 }
507 }
508
509 /* Display a symbol on stdout. Handles the display of control characters and
510 multibye characters (assuming the host environment supports them).
511
512 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
513
514 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
515 padding as necessary.
516
517 Returns the number of emitted characters. */
518
519 static unsigned int
520 print_symbol (signed int width, const char *symbol)
521 {
522 bfd_boolean extra_padding = FALSE;
523 signed int num_printed = 0;
524 #ifdef HAVE_MBSTATE_T
525 mbstate_t state;
526 #endif
527 unsigned int width_remaining;
528
529 if (width < 0)
530 {
531 /* Keep the width positive. This helps the code below. */
532 width = - width;
533 extra_padding = TRUE;
534 }
535 else if (width == 0)
536 return 0;
537
538 if (do_wide)
539 /* Set the remaining width to a very large value.
540 This simplifies the code below. */
541 width_remaining = INT_MAX;
542 else
543 width_remaining = width;
544
545 #ifdef HAVE_MBSTATE_T
546 /* Initialise the multibyte conversion state. */
547 memset (& state, 0, sizeof (state));
548 #endif
549
550 while (width_remaining)
551 {
552 size_t n;
553 const char c = *symbol++;
554
555 if (c == 0)
556 break;
557
558 /* Do not print control characters directly as they can affect terminal
559 settings. Such characters usually appear in the names generated
560 by the assembler for local labels. */
561 if (ISCNTRL (c))
562 {
563 if (width_remaining < 2)
564 break;
565
566 printf ("^%c", c + 0x40);
567 width_remaining -= 2;
568 num_printed += 2;
569 }
570 else if (ISPRINT (c))
571 {
572 putchar (c);
573 width_remaining --;
574 num_printed ++;
575 }
576 else
577 {
578 #ifdef HAVE_MBSTATE_T
579 wchar_t w;
580 #endif
581 /* Let printf do the hard work of displaying multibyte characters. */
582 printf ("%.1s", symbol - 1);
583 width_remaining --;
584 num_printed ++;
585
586 #ifdef HAVE_MBSTATE_T
587 /* Try to find out how many bytes made up the character that was
588 just printed. Advance the symbol pointer past the bytes that
589 were displayed. */
590 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
591 #else
592 n = 1;
593 #endif
594 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
595 symbol += (n - 1);
596 }
597 }
598
599 if (extra_padding && num_printed < width)
600 {
601 /* Fill in the remaining spaces. */
602 printf ("%-*s", width - num_printed, " ");
603 num_printed = width;
604 }
605
606 return num_printed;
607 }
608
609 /* Returns a pointer to a static buffer containing a printable version of
610 the given section's name. Like print_symbol, except that it does not try
611 to print multibyte characters, it just interprets them as hex values. */
612
613 static const char *
614 printable_section_name (Filedata * filedata, const Elf_Internal_Shdr * sec)
615 {
616 #define MAX_PRINT_SEC_NAME_LEN 128
617 static char sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
618 const char * name = SECTION_NAME (sec);
619 char * buf = sec_name_buf;
620 char c;
621 unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
622
623 while ((c = * name ++) != 0)
624 {
625 if (ISCNTRL (c))
626 {
627 if (remaining < 2)
628 break;
629
630 * buf ++ = '^';
631 * buf ++ = c + 0x40;
632 remaining -= 2;
633 }
634 else if (ISPRINT (c))
635 {
636 * buf ++ = c;
637 remaining -= 1;
638 }
639 else
640 {
641 static char hex[17] = "0123456789ABCDEF";
642
643 if (remaining < 4)
644 break;
645 * buf ++ = '<';
646 * buf ++ = hex[(c & 0xf0) >> 4];
647 * buf ++ = hex[c & 0x0f];
648 * buf ++ = '>';
649 remaining -= 4;
650 }
651
652 if (remaining == 0)
653 break;
654 }
655
656 * buf = 0;
657 return sec_name_buf;
658 }
659
660 static const char *
661 printable_section_name_from_index (Filedata * filedata, unsigned long ndx)
662 {
663 if (ndx >= filedata->file_header.e_shnum)
664 return _("<corrupt>");
665
666 return printable_section_name (filedata, filedata->section_headers + ndx);
667 }
668
669 /* Return a pointer to section NAME, or NULL if no such section exists. */
670
671 static Elf_Internal_Shdr *
672 find_section (Filedata * filedata, const char * name)
673 {
674 unsigned int i;
675
676 if (filedata->section_headers == NULL)
677 return NULL;
678
679 for (i = 0; i < filedata->file_header.e_shnum; i++)
680 if (streq (SECTION_NAME (filedata->section_headers + i), name))
681 return filedata->section_headers + i;
682
683 return NULL;
684 }
685
686 /* Return a pointer to a section containing ADDR, or NULL if no such
687 section exists. */
688
689 static Elf_Internal_Shdr *
690 find_section_by_address (Filedata * filedata, bfd_vma addr)
691 {
692 unsigned int i;
693
694 if (filedata->section_headers == NULL)
695 return NULL;
696
697 for (i = 0; i < filedata->file_header.e_shnum; i++)
698 {
699 Elf_Internal_Shdr *sec = filedata->section_headers + i;
700
701 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
702 return sec;
703 }
704
705 return NULL;
706 }
707
708 static Elf_Internal_Shdr *
709 find_section_by_type (Filedata * filedata, unsigned int type)
710 {
711 unsigned int i;
712
713 if (filedata->section_headers == NULL)
714 return NULL;
715
716 for (i = 0; i < filedata->file_header.e_shnum; i++)
717 {
718 Elf_Internal_Shdr *sec = filedata->section_headers + i;
719
720 if (sec->sh_type == type)
721 return sec;
722 }
723
724 return NULL;
725 }
726
727 /* Return a pointer to section NAME, or NULL if no such section exists,
728 restricted to the list of sections given in SET. */
729
730 static Elf_Internal_Shdr *
731 find_section_in_set (Filedata * filedata, const char * name, unsigned int * set)
732 {
733 unsigned int i;
734
735 if (filedata->section_headers == NULL)
736 return NULL;
737
738 if (set != NULL)
739 {
740 while ((i = *set++) > 0)
741 {
742 /* See PR 21156 for a reproducer. */
743 if (i >= filedata->file_header.e_shnum)
744 continue; /* FIXME: Should we issue an error message ? */
745
746 if (streq (SECTION_NAME (filedata->section_headers + i), name))
747 return filedata->section_headers + i;
748 }
749 }
750
751 return find_section (filedata, name);
752 }
753
754 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
755 This OS has so many departures from the ELF standard that we test it at
756 many places. */
757
758 static inline bfd_boolean
759 is_ia64_vms (Filedata * filedata)
760 {
761 return filedata->file_header.e_machine == EM_IA_64
762 && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
763 }
764
765 /* Guess the relocation size commonly used by the specific machines. */
766
767 static bfd_boolean
768 guess_is_rela (unsigned int e_machine)
769 {
770 switch (e_machine)
771 {
772 /* Targets that use REL relocations. */
773 case EM_386:
774 case EM_IAMCU:
775 case EM_960:
776 case EM_ARM:
777 case EM_D10V:
778 case EM_CYGNUS_D10V:
779 case EM_DLX:
780 case EM_MIPS:
781 case EM_MIPS_RS3_LE:
782 case EM_CYGNUS_M32R:
783 case EM_SCORE:
784 case EM_XGATE:
785 case EM_NFP:
786 case EM_BPF:
787 return FALSE;
788
789 /* Targets that use RELA relocations. */
790 case EM_68K:
791 case EM_860:
792 case EM_AARCH64:
793 case EM_ADAPTEVA_EPIPHANY:
794 case EM_ALPHA:
795 case EM_ALTERA_NIOS2:
796 case EM_ARC:
797 case EM_ARC_COMPACT:
798 case EM_ARC_COMPACT2:
799 case EM_AVR:
800 case EM_AVR_OLD:
801 case EM_BLACKFIN:
802 case EM_CR16:
803 case EM_CRIS:
804 case EM_CRX:
805 case EM_CSKY:
806 case EM_D30V:
807 case EM_CYGNUS_D30V:
808 case EM_FR30:
809 case EM_FT32:
810 case EM_CYGNUS_FR30:
811 case EM_CYGNUS_FRV:
812 case EM_H8S:
813 case EM_H8_300:
814 case EM_H8_300H:
815 case EM_IA_64:
816 case EM_IP2K:
817 case EM_IP2K_OLD:
818 case EM_IQ2000:
819 case EM_LATTICEMICO32:
820 case EM_M32C_OLD:
821 case EM_M32C:
822 case EM_M32R:
823 case EM_MCORE:
824 case EM_CYGNUS_MEP:
825 case EM_METAG:
826 case EM_MMIX:
827 case EM_MN10200:
828 case EM_CYGNUS_MN10200:
829 case EM_MN10300:
830 case EM_CYGNUS_MN10300:
831 case EM_MOXIE:
832 case EM_MSP430:
833 case EM_MSP430_OLD:
834 case EM_MT:
835 case EM_NDS32:
836 case EM_NIOS32:
837 case EM_OR1K:
838 case EM_PPC64:
839 case EM_PPC:
840 case EM_TI_PRU:
841 case EM_RISCV:
842 case EM_RL78:
843 case EM_RX:
844 case EM_S390:
845 case EM_S390_OLD:
846 case EM_SH:
847 case EM_SPARC:
848 case EM_SPARC32PLUS:
849 case EM_SPARCV9:
850 case EM_SPU:
851 case EM_TI_C6000:
852 case EM_TILEGX:
853 case EM_TILEPRO:
854 case EM_V800:
855 case EM_V850:
856 case EM_CYGNUS_V850:
857 case EM_VAX:
858 case EM_VISIUM:
859 case EM_X86_64:
860 case EM_L1OM:
861 case EM_K1OM:
862 case EM_XSTORMY16:
863 case EM_XTENSA:
864 case EM_XTENSA_OLD:
865 case EM_MICROBLAZE:
866 case EM_MICROBLAZE_OLD:
867 case EM_WEBASSEMBLY:
868 return TRUE;
869
870 case EM_68HC05:
871 case EM_68HC08:
872 case EM_68HC11:
873 case EM_68HC16:
874 case EM_FX66:
875 case EM_ME16:
876 case EM_MMA:
877 case EM_NCPU:
878 case EM_NDR1:
879 case EM_PCP:
880 case EM_ST100:
881 case EM_ST19:
882 case EM_ST7:
883 case EM_ST9PLUS:
884 case EM_STARCORE:
885 case EM_SVX:
886 case EM_TINYJ:
887 default:
888 warn (_("Don't know about relocations on this machine architecture\n"));
889 return FALSE;
890 }
891 }
892
893 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
894 Returns TRUE upon success, FALSE otherwise. If successful then a
895 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
896 and the number of relocs loaded is placed in *NRELASP. It is the caller's
897 responsibility to free the allocated buffer. */
898
899 static bfd_boolean
900 slurp_rela_relocs (Filedata * filedata,
901 unsigned long rel_offset,
902 unsigned long rel_size,
903 Elf_Internal_Rela ** relasp,
904 unsigned long * nrelasp)
905 {
906 Elf_Internal_Rela * relas;
907 size_t nrelas;
908 unsigned int i;
909
910 if (is_32bit_elf)
911 {
912 Elf32_External_Rela * erelas;
913
914 erelas = (Elf32_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
915 rel_size, _("32-bit relocation data"));
916 if (!erelas)
917 return FALSE;
918
919 nrelas = rel_size / sizeof (Elf32_External_Rela);
920
921 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
922 sizeof (Elf_Internal_Rela));
923
924 if (relas == NULL)
925 {
926 free (erelas);
927 error (_("out of memory parsing relocs\n"));
928 return FALSE;
929 }
930
931 for (i = 0; i < nrelas; i++)
932 {
933 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
934 relas[i].r_info = BYTE_GET (erelas[i].r_info);
935 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
936 }
937
938 free (erelas);
939 }
940 else
941 {
942 Elf64_External_Rela * erelas;
943
944 erelas = (Elf64_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
945 rel_size, _("64-bit relocation data"));
946 if (!erelas)
947 return FALSE;
948
949 nrelas = rel_size / sizeof (Elf64_External_Rela);
950
951 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
952 sizeof (Elf_Internal_Rela));
953
954 if (relas == NULL)
955 {
956 free (erelas);
957 error (_("out of memory parsing relocs\n"));
958 return FALSE;
959 }
960
961 for (i = 0; i < nrelas; i++)
962 {
963 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
964 relas[i].r_info = BYTE_GET (erelas[i].r_info);
965 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
966
967 /* The #ifdef BFD64 below is to prevent a compile time
968 warning. We know that if we do not have a 64 bit data
969 type that we will never execute this code anyway. */
970 #ifdef BFD64
971 if (filedata->file_header.e_machine == EM_MIPS
972 && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
973 {
974 /* In little-endian objects, r_info isn't really a
975 64-bit little-endian value: it has a 32-bit
976 little-endian symbol index followed by four
977 individual byte fields. Reorder INFO
978 accordingly. */
979 bfd_vma inf = relas[i].r_info;
980 inf = (((inf & 0xffffffff) << 32)
981 | ((inf >> 56) & 0xff)
982 | ((inf >> 40) & 0xff00)
983 | ((inf >> 24) & 0xff0000)
984 | ((inf >> 8) & 0xff000000));
985 relas[i].r_info = inf;
986 }
987 #endif /* BFD64 */
988 }
989
990 free (erelas);
991 }
992
993 *relasp = relas;
994 *nrelasp = nrelas;
995 return TRUE;
996 }
997
998 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
999 Returns TRUE upon success, FALSE otherwise. If successful then a
1000 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
1001 and the number of relocs loaded is placed in *NRELSP. It is the caller's
1002 responsibility to free the allocated buffer. */
1003
1004 static bfd_boolean
1005 slurp_rel_relocs (Filedata * filedata,
1006 unsigned long rel_offset,
1007 unsigned long rel_size,
1008 Elf_Internal_Rela ** relsp,
1009 unsigned long * nrelsp)
1010 {
1011 Elf_Internal_Rela * rels;
1012 size_t nrels;
1013 unsigned int i;
1014
1015 if (is_32bit_elf)
1016 {
1017 Elf32_External_Rel * erels;
1018
1019 erels = (Elf32_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1020 rel_size, _("32-bit relocation data"));
1021 if (!erels)
1022 return FALSE;
1023
1024 nrels = rel_size / sizeof (Elf32_External_Rel);
1025
1026 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1027
1028 if (rels == NULL)
1029 {
1030 free (erels);
1031 error (_("out of memory parsing relocs\n"));
1032 return FALSE;
1033 }
1034
1035 for (i = 0; i < nrels; i++)
1036 {
1037 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1038 rels[i].r_info = BYTE_GET (erels[i].r_info);
1039 rels[i].r_addend = 0;
1040 }
1041
1042 free (erels);
1043 }
1044 else
1045 {
1046 Elf64_External_Rel * erels;
1047
1048 erels = (Elf64_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1049 rel_size, _("64-bit relocation data"));
1050 if (!erels)
1051 return FALSE;
1052
1053 nrels = rel_size / sizeof (Elf64_External_Rel);
1054
1055 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1056
1057 if (rels == NULL)
1058 {
1059 free (erels);
1060 error (_("out of memory parsing relocs\n"));
1061 return FALSE;
1062 }
1063
1064 for (i = 0; i < nrels; i++)
1065 {
1066 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1067 rels[i].r_info = BYTE_GET (erels[i].r_info);
1068 rels[i].r_addend = 0;
1069
1070 /* The #ifdef BFD64 below is to prevent a compile time
1071 warning. We know that if we do not have a 64 bit data
1072 type that we will never execute this code anyway. */
1073 #ifdef BFD64
1074 if (filedata->file_header.e_machine == EM_MIPS
1075 && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
1076 {
1077 /* In little-endian objects, r_info isn't really a
1078 64-bit little-endian value: it has a 32-bit
1079 little-endian symbol index followed by four
1080 individual byte fields. Reorder INFO
1081 accordingly. */
1082 bfd_vma inf = rels[i].r_info;
1083 inf = (((inf & 0xffffffff) << 32)
1084 | ((inf >> 56) & 0xff)
1085 | ((inf >> 40) & 0xff00)
1086 | ((inf >> 24) & 0xff0000)
1087 | ((inf >> 8) & 0xff000000));
1088 rels[i].r_info = inf;
1089 }
1090 #endif /* BFD64 */
1091 }
1092
1093 free (erels);
1094 }
1095
1096 *relsp = rels;
1097 *nrelsp = nrels;
1098 return TRUE;
1099 }
1100
1101 /* Returns the reloc type extracted from the reloc info field. */
1102
1103 static unsigned int
1104 get_reloc_type (Filedata * filedata, bfd_vma reloc_info)
1105 {
1106 if (is_32bit_elf)
1107 return ELF32_R_TYPE (reloc_info);
1108
1109 switch (filedata->file_header.e_machine)
1110 {
1111 case EM_MIPS:
1112 /* Note: We assume that reloc_info has already been adjusted for us. */
1113 return ELF64_MIPS_R_TYPE (reloc_info);
1114
1115 case EM_SPARCV9:
1116 return ELF64_R_TYPE_ID (reloc_info);
1117
1118 default:
1119 return ELF64_R_TYPE (reloc_info);
1120 }
1121 }
1122
1123 /* Return the symbol index extracted from the reloc info field. */
1124
1125 static bfd_vma
1126 get_reloc_symindex (bfd_vma reloc_info)
1127 {
1128 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1129 }
1130
1131 static inline bfd_boolean
1132 uses_msp430x_relocs (Filedata * filedata)
1133 {
1134 return
1135 filedata->file_header.e_machine == EM_MSP430 /* Paranoia. */
1136 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1137 && (((filedata->file_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1138 /* TI compiler uses ELFOSABI_NONE. */
1139 || (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1140 }
1141
1142 /* Display the contents of the relocation data found at the specified
1143 offset. */
1144
1145 static bfd_boolean
1146 dump_relocations (Filedata * filedata,
1147 unsigned long rel_offset,
1148 unsigned long rel_size,
1149 Elf_Internal_Sym * symtab,
1150 unsigned long nsyms,
1151 char * strtab,
1152 unsigned long strtablen,
1153 int is_rela,
1154 bfd_boolean is_dynsym)
1155 {
1156 unsigned long i;
1157 Elf_Internal_Rela * rels;
1158 bfd_boolean res = TRUE;
1159
1160 if (is_rela == UNKNOWN)
1161 is_rela = guess_is_rela (filedata->file_header.e_machine);
1162
1163 if (is_rela)
1164 {
1165 if (!slurp_rela_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1166 return FALSE;
1167 }
1168 else
1169 {
1170 if (!slurp_rel_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1171 return FALSE;
1172 }
1173
1174 if (is_32bit_elf)
1175 {
1176 if (is_rela)
1177 {
1178 if (do_wide)
1179 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1180 else
1181 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1182 }
1183 else
1184 {
1185 if (do_wide)
1186 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1187 else
1188 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1189 }
1190 }
1191 else
1192 {
1193 if (is_rela)
1194 {
1195 if (do_wide)
1196 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1197 else
1198 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1199 }
1200 else
1201 {
1202 if (do_wide)
1203 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1204 else
1205 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1206 }
1207 }
1208
1209 for (i = 0; i < rel_size; i++)
1210 {
1211 const char * rtype;
1212 bfd_vma offset;
1213 bfd_vma inf;
1214 bfd_vma symtab_index;
1215 bfd_vma type;
1216
1217 offset = rels[i].r_offset;
1218 inf = rels[i].r_info;
1219
1220 type = get_reloc_type (filedata, inf);
1221 symtab_index = get_reloc_symindex (inf);
1222
1223 if (is_32bit_elf)
1224 {
1225 printf ("%8.8lx %8.8lx ",
1226 (unsigned long) offset & 0xffffffff,
1227 (unsigned long) inf & 0xffffffff);
1228 }
1229 else
1230 {
1231 #if BFD_HOST_64BIT_LONG
1232 printf (do_wide
1233 ? "%16.16lx %16.16lx "
1234 : "%12.12lx %12.12lx ",
1235 offset, inf);
1236 #elif BFD_HOST_64BIT_LONG_LONG
1237 #ifndef __MSVCRT__
1238 printf (do_wide
1239 ? "%16.16llx %16.16llx "
1240 : "%12.12llx %12.12llx ",
1241 offset, inf);
1242 #else
1243 printf (do_wide
1244 ? "%16.16I64x %16.16I64x "
1245 : "%12.12I64x %12.12I64x ",
1246 offset, inf);
1247 #endif
1248 #else
1249 printf (do_wide
1250 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1251 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1252 _bfd_int64_high (offset),
1253 _bfd_int64_low (offset),
1254 _bfd_int64_high (inf),
1255 _bfd_int64_low (inf));
1256 #endif
1257 }
1258
1259 switch (filedata->file_header.e_machine)
1260 {
1261 default:
1262 rtype = NULL;
1263 break;
1264
1265 case EM_AARCH64:
1266 rtype = elf_aarch64_reloc_type (type);
1267 break;
1268
1269 case EM_M32R:
1270 case EM_CYGNUS_M32R:
1271 rtype = elf_m32r_reloc_type (type);
1272 break;
1273
1274 case EM_386:
1275 case EM_IAMCU:
1276 rtype = elf_i386_reloc_type (type);
1277 break;
1278
1279 case EM_68HC11:
1280 case EM_68HC12:
1281 rtype = elf_m68hc11_reloc_type (type);
1282 break;
1283
1284 case EM_S12Z:
1285 rtype = elf_s12z_reloc_type (type);
1286 break;
1287
1288 case EM_68K:
1289 rtype = elf_m68k_reloc_type (type);
1290 break;
1291
1292 case EM_960:
1293 rtype = elf_i960_reloc_type (type);
1294 break;
1295
1296 case EM_AVR:
1297 case EM_AVR_OLD:
1298 rtype = elf_avr_reloc_type (type);
1299 break;
1300
1301 case EM_OLD_SPARCV9:
1302 case EM_SPARC32PLUS:
1303 case EM_SPARCV9:
1304 case EM_SPARC:
1305 rtype = elf_sparc_reloc_type (type);
1306 break;
1307
1308 case EM_SPU:
1309 rtype = elf_spu_reloc_type (type);
1310 break;
1311
1312 case EM_V800:
1313 rtype = v800_reloc_type (type);
1314 break;
1315 case EM_V850:
1316 case EM_CYGNUS_V850:
1317 rtype = v850_reloc_type (type);
1318 break;
1319
1320 case EM_D10V:
1321 case EM_CYGNUS_D10V:
1322 rtype = elf_d10v_reloc_type (type);
1323 break;
1324
1325 case EM_D30V:
1326 case EM_CYGNUS_D30V:
1327 rtype = elf_d30v_reloc_type (type);
1328 break;
1329
1330 case EM_DLX:
1331 rtype = elf_dlx_reloc_type (type);
1332 break;
1333
1334 case EM_SH:
1335 rtype = elf_sh_reloc_type (type);
1336 break;
1337
1338 case EM_MN10300:
1339 case EM_CYGNUS_MN10300:
1340 rtype = elf_mn10300_reloc_type (type);
1341 break;
1342
1343 case EM_MN10200:
1344 case EM_CYGNUS_MN10200:
1345 rtype = elf_mn10200_reloc_type (type);
1346 break;
1347
1348 case EM_FR30:
1349 case EM_CYGNUS_FR30:
1350 rtype = elf_fr30_reloc_type (type);
1351 break;
1352
1353 case EM_CYGNUS_FRV:
1354 rtype = elf_frv_reloc_type (type);
1355 break;
1356
1357 case EM_CSKY:
1358 rtype = elf_csky_reloc_type (type);
1359 break;
1360
1361 case EM_FT32:
1362 rtype = elf_ft32_reloc_type (type);
1363 break;
1364
1365 case EM_MCORE:
1366 rtype = elf_mcore_reloc_type (type);
1367 break;
1368
1369 case EM_MMIX:
1370 rtype = elf_mmix_reloc_type (type);
1371 break;
1372
1373 case EM_MOXIE:
1374 rtype = elf_moxie_reloc_type (type);
1375 break;
1376
1377 case EM_MSP430:
1378 if (uses_msp430x_relocs (filedata))
1379 {
1380 rtype = elf_msp430x_reloc_type (type);
1381 break;
1382 }
1383 /* Fall through. */
1384 case EM_MSP430_OLD:
1385 rtype = elf_msp430_reloc_type (type);
1386 break;
1387
1388 case EM_NDS32:
1389 rtype = elf_nds32_reloc_type (type);
1390 break;
1391
1392 case EM_PPC:
1393 rtype = elf_ppc_reloc_type (type);
1394 break;
1395
1396 case EM_PPC64:
1397 rtype = elf_ppc64_reloc_type (type);
1398 break;
1399
1400 case EM_MIPS:
1401 case EM_MIPS_RS3_LE:
1402 rtype = elf_mips_reloc_type (type);
1403 break;
1404
1405 case EM_RISCV:
1406 rtype = elf_riscv_reloc_type (type);
1407 break;
1408
1409 case EM_ALPHA:
1410 rtype = elf_alpha_reloc_type (type);
1411 break;
1412
1413 case EM_ARM:
1414 rtype = elf_arm_reloc_type (type);
1415 break;
1416
1417 case EM_ARC:
1418 case EM_ARC_COMPACT:
1419 case EM_ARC_COMPACT2:
1420 rtype = elf_arc_reloc_type (type);
1421 break;
1422
1423 case EM_PARISC:
1424 rtype = elf_hppa_reloc_type (type);
1425 break;
1426
1427 case EM_H8_300:
1428 case EM_H8_300H:
1429 case EM_H8S:
1430 rtype = elf_h8_reloc_type (type);
1431 break;
1432
1433 case EM_OR1K:
1434 rtype = elf_or1k_reloc_type (type);
1435 break;
1436
1437 case EM_PJ:
1438 case EM_PJ_OLD:
1439 rtype = elf_pj_reloc_type (type);
1440 break;
1441 case EM_IA_64:
1442 rtype = elf_ia64_reloc_type (type);
1443 break;
1444
1445 case EM_CRIS:
1446 rtype = elf_cris_reloc_type (type);
1447 break;
1448
1449 case EM_860:
1450 rtype = elf_i860_reloc_type (type);
1451 break;
1452
1453 case EM_X86_64:
1454 case EM_L1OM:
1455 case EM_K1OM:
1456 rtype = elf_x86_64_reloc_type (type);
1457 break;
1458
1459 case EM_S370:
1460 rtype = i370_reloc_type (type);
1461 break;
1462
1463 case EM_S390_OLD:
1464 case EM_S390:
1465 rtype = elf_s390_reloc_type (type);
1466 break;
1467
1468 case EM_SCORE:
1469 rtype = elf_score_reloc_type (type);
1470 break;
1471
1472 case EM_XSTORMY16:
1473 rtype = elf_xstormy16_reloc_type (type);
1474 break;
1475
1476 case EM_CRX:
1477 rtype = elf_crx_reloc_type (type);
1478 break;
1479
1480 case EM_VAX:
1481 rtype = elf_vax_reloc_type (type);
1482 break;
1483
1484 case EM_VISIUM:
1485 rtype = elf_visium_reloc_type (type);
1486 break;
1487
1488 case EM_BPF:
1489 rtype = elf_bpf_reloc_type (type);
1490 break;
1491
1492 case EM_ADAPTEVA_EPIPHANY:
1493 rtype = elf_epiphany_reloc_type (type);
1494 break;
1495
1496 case EM_IP2K:
1497 case EM_IP2K_OLD:
1498 rtype = elf_ip2k_reloc_type (type);
1499 break;
1500
1501 case EM_IQ2000:
1502 rtype = elf_iq2000_reloc_type (type);
1503 break;
1504
1505 case EM_XTENSA_OLD:
1506 case EM_XTENSA:
1507 rtype = elf_xtensa_reloc_type (type);
1508 break;
1509
1510 case EM_LATTICEMICO32:
1511 rtype = elf_lm32_reloc_type (type);
1512 break;
1513
1514 case EM_M32C_OLD:
1515 case EM_M32C:
1516 rtype = elf_m32c_reloc_type (type);
1517 break;
1518
1519 case EM_MT:
1520 rtype = elf_mt_reloc_type (type);
1521 break;
1522
1523 case EM_BLACKFIN:
1524 rtype = elf_bfin_reloc_type (type);
1525 break;
1526
1527 case EM_CYGNUS_MEP:
1528 rtype = elf_mep_reloc_type (type);
1529 break;
1530
1531 case EM_CR16:
1532 rtype = elf_cr16_reloc_type (type);
1533 break;
1534
1535 case EM_MICROBLAZE:
1536 case EM_MICROBLAZE_OLD:
1537 rtype = elf_microblaze_reloc_type (type);
1538 break;
1539
1540 case EM_RL78:
1541 rtype = elf_rl78_reloc_type (type);
1542 break;
1543
1544 case EM_RX:
1545 rtype = elf_rx_reloc_type (type);
1546 break;
1547
1548 case EM_METAG:
1549 rtype = elf_metag_reloc_type (type);
1550 break;
1551
1552 case EM_XC16X:
1553 case EM_C166:
1554 rtype = elf_xc16x_reloc_type (type);
1555 break;
1556
1557 case EM_TI_C6000:
1558 rtype = elf_tic6x_reloc_type (type);
1559 break;
1560
1561 case EM_TILEGX:
1562 rtype = elf_tilegx_reloc_type (type);
1563 break;
1564
1565 case EM_TILEPRO:
1566 rtype = elf_tilepro_reloc_type (type);
1567 break;
1568
1569 case EM_WEBASSEMBLY:
1570 rtype = elf_wasm32_reloc_type (type);
1571 break;
1572
1573 case EM_XGATE:
1574 rtype = elf_xgate_reloc_type (type);
1575 break;
1576
1577 case EM_ALTERA_NIOS2:
1578 rtype = elf_nios2_reloc_type (type);
1579 break;
1580
1581 case EM_TI_PRU:
1582 rtype = elf_pru_reloc_type (type);
1583 break;
1584
1585 case EM_NFP:
1586 if (EF_NFP_MACH (filedata->file_header.e_flags) == E_NFP_MACH_3200)
1587 rtype = elf_nfp3200_reloc_type (type);
1588 else
1589 rtype = elf_nfp_reloc_type (type);
1590 break;
1591
1592 case EM_AMDGPU:
1593 rtype = elf_amdgcn_reloc_type (type);
1594 break;
1595 }
1596
1597 if (rtype == NULL)
1598 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1599 else
1600 printf (do_wide ? "%-22s" : "%-17.17s", rtype);
1601
1602 if (filedata->file_header.e_machine == EM_ALPHA
1603 && rtype != NULL
1604 && streq (rtype, "R_ALPHA_LITUSE")
1605 && is_rela)
1606 {
1607 switch (rels[i].r_addend)
1608 {
1609 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1610 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1611 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1612 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1613 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1614 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1615 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1616 default: rtype = NULL;
1617 }
1618
1619 if (rtype)
1620 printf (" (%s)", rtype);
1621 else
1622 {
1623 putchar (' ');
1624 printf (_("<unknown addend: %lx>"),
1625 (unsigned long) rels[i].r_addend);
1626 res = FALSE;
1627 }
1628 }
1629 else if (symtab_index)
1630 {
1631 if (symtab == NULL || symtab_index >= nsyms)
1632 {
1633 error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index);
1634 res = FALSE;
1635 }
1636 else
1637 {
1638 Elf_Internal_Sym * psym;
1639 const char * version_string;
1640 enum versioned_symbol_info sym_info;
1641 unsigned short vna_other;
1642
1643 psym = symtab + symtab_index;
1644
1645 version_string
1646 = get_symbol_version_string (filedata, is_dynsym,
1647 strtab, strtablen,
1648 symtab_index,
1649 psym,
1650 &sym_info,
1651 &vna_other);
1652
1653 printf (" ");
1654
1655 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1656 {
1657 const char * name;
1658 unsigned int len;
1659 unsigned int width = is_32bit_elf ? 8 : 14;
1660
1661 /* Relocations against GNU_IFUNC symbols do not use the value
1662 of the symbol as the address to relocate against. Instead
1663 they invoke the function named by the symbol and use its
1664 result as the address for relocation.
1665
1666 To indicate this to the user, do not display the value of
1667 the symbol in the "Symbols's Value" field. Instead show
1668 its name followed by () as a hint that the symbol is
1669 invoked. */
1670
1671 if (strtab == NULL
1672 || psym->st_name == 0
1673 || psym->st_name >= strtablen)
1674 name = "??";
1675 else
1676 name = strtab + psym->st_name;
1677
1678 len = print_symbol (width, name);
1679 if (version_string)
1680 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1681 version_string);
1682 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1683 }
1684 else
1685 {
1686 print_vma (psym->st_value, LONG_HEX);
1687
1688 printf (is_32bit_elf ? " " : " ");
1689 }
1690
1691 if (psym->st_name == 0)
1692 {
1693 const char * sec_name = "<null>";
1694 char name_buf[40];
1695
1696 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1697 {
1698 if (psym->st_shndx < filedata->file_header.e_shnum)
1699 sec_name = SECTION_NAME (filedata->section_headers + psym->st_shndx);
1700 else if (psym->st_shndx == SHN_ABS)
1701 sec_name = "ABS";
1702 else if (psym->st_shndx == SHN_COMMON)
1703 sec_name = "COMMON";
1704 else if ((filedata->file_header.e_machine == EM_MIPS
1705 && psym->st_shndx == SHN_MIPS_SCOMMON)
1706 || (filedata->file_header.e_machine == EM_TI_C6000
1707 && psym->st_shndx == SHN_TIC6X_SCOMMON))
1708 sec_name = "SCOMMON";
1709 else if (filedata->file_header.e_machine == EM_MIPS
1710 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1711 sec_name = "SUNDEF";
1712 else if ((filedata->file_header.e_machine == EM_X86_64
1713 || filedata->file_header.e_machine == EM_L1OM
1714 || filedata->file_header.e_machine == EM_K1OM)
1715 && psym->st_shndx == SHN_X86_64_LCOMMON)
1716 sec_name = "LARGE_COMMON";
1717 else if (filedata->file_header.e_machine == EM_IA_64
1718 && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1719 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1720 sec_name = "ANSI_COM";
1721 else if (is_ia64_vms (filedata)
1722 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1723 sec_name = "VMS_SYMVEC";
1724 else
1725 {
1726 sprintf (name_buf, "<section 0x%x>",
1727 (unsigned int) psym->st_shndx);
1728 sec_name = name_buf;
1729 }
1730 }
1731 print_symbol (22, sec_name);
1732 }
1733 else if (strtab == NULL)
1734 printf (_("<string table index: %3ld>"), psym->st_name);
1735 else if (psym->st_name >= strtablen)
1736 {
1737 error (_("<corrupt string table index: %3ld>"), psym->st_name);
1738 res = FALSE;
1739 }
1740 else
1741 {
1742 print_symbol (22, strtab + psym->st_name);
1743 if (version_string)
1744 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1745 version_string);
1746 }
1747
1748 if (is_rela)
1749 {
1750 bfd_vma off = rels[i].r_addend;
1751
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 }
1759 else if (is_rela)
1760 {
1761 bfd_vma off = rels[i].r_addend;
1762
1763 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1764 if ((bfd_signed_vma) off < 0)
1765 printf ("-%" BFD_VMA_FMT "x", - off);
1766 else
1767 printf ("%" BFD_VMA_FMT "x", off);
1768 }
1769
1770 if (filedata->file_header.e_machine == EM_SPARCV9
1771 && rtype != NULL
1772 && streq (rtype, "R_SPARC_OLO10"))
1773 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1774
1775 putchar ('\n');
1776
1777 #ifdef BFD64
1778 if (! is_32bit_elf && filedata->file_header.e_machine == EM_MIPS)
1779 {
1780 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1781 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1782 const char * rtype2 = elf_mips_reloc_type (type2);
1783 const char * rtype3 = elf_mips_reloc_type (type3);
1784
1785 printf (" Type2: ");
1786
1787 if (rtype2 == NULL)
1788 printf (_("unrecognized: %-7lx"),
1789 (unsigned long) type2 & 0xffffffff);
1790 else
1791 printf ("%-17.17s", rtype2);
1792
1793 printf ("\n Type3: ");
1794
1795 if (rtype3 == NULL)
1796 printf (_("unrecognized: %-7lx"),
1797 (unsigned long) type3 & 0xffffffff);
1798 else
1799 printf ("%-17.17s", rtype3);
1800
1801 putchar ('\n');
1802 }
1803 #endif /* BFD64 */
1804 }
1805
1806 free (rels);
1807
1808 return res;
1809 }
1810
1811 static const char *
1812 get_aarch64_dynamic_type (unsigned long type)
1813 {
1814 switch (type)
1815 {
1816 case DT_AARCH64_BTI_PLT: return "AARCH64_BTI_PLT";
1817 case DT_AARCH64_PAC_PLT: return "AARCH64_PAC_PLT";
1818 case DT_AARCH64_VARIANT_PCS: return "AARCH64_VARIANT_PCS";
1819 default:
1820 return NULL;
1821 }
1822 }
1823
1824 static const char *
1825 get_mips_dynamic_type (unsigned long type)
1826 {
1827 switch (type)
1828 {
1829 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1830 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1831 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1832 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1833 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1834 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1835 case DT_MIPS_MSYM: return "MIPS_MSYM";
1836 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1837 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1838 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1839 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1840 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1841 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1842 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1843 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1844 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1845 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1846 case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
1847 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1848 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1849 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1850 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1851 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1852 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1853 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1854 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1855 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1856 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1857 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1858 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1859 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1860 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1861 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1862 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1863 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1864 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1865 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1866 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1867 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1868 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1869 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1870 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1871 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1872 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1873 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1874 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1875 case DT_MIPS_XHASH: return "MIPS_XHASH";
1876 default:
1877 return NULL;
1878 }
1879 }
1880
1881 static const char *
1882 get_sparc64_dynamic_type (unsigned long type)
1883 {
1884 switch (type)
1885 {
1886 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1887 default:
1888 return NULL;
1889 }
1890 }
1891
1892 static const char *
1893 get_ppc_dynamic_type (unsigned long type)
1894 {
1895 switch (type)
1896 {
1897 case DT_PPC_GOT: return "PPC_GOT";
1898 case DT_PPC_OPT: return "PPC_OPT";
1899 default:
1900 return NULL;
1901 }
1902 }
1903
1904 static const char *
1905 get_ppc64_dynamic_type (unsigned long type)
1906 {
1907 switch (type)
1908 {
1909 case DT_PPC64_GLINK: return "PPC64_GLINK";
1910 case DT_PPC64_OPD: return "PPC64_OPD";
1911 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1912 case DT_PPC64_OPT: return "PPC64_OPT";
1913 default:
1914 return NULL;
1915 }
1916 }
1917
1918 static const char *
1919 get_parisc_dynamic_type (unsigned long type)
1920 {
1921 switch (type)
1922 {
1923 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1924 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1925 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1926 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1927 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1928 case DT_HP_PREINIT: return "HP_PREINIT";
1929 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1930 case DT_HP_NEEDED: return "HP_NEEDED";
1931 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1932 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1933 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1934 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1935 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1936 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1937 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1938 case DT_HP_FILTERED: return "HP_FILTERED";
1939 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1940 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1941 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1942 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1943 case DT_PLT: return "PLT";
1944 case DT_PLT_SIZE: return "PLT_SIZE";
1945 case DT_DLT: return "DLT";
1946 case DT_DLT_SIZE: return "DLT_SIZE";
1947 default:
1948 return NULL;
1949 }
1950 }
1951
1952 static const char *
1953 get_ia64_dynamic_type (unsigned long type)
1954 {
1955 switch (type)
1956 {
1957 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1958 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1959 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1960 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1961 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1962 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1963 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1964 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1965 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1966 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1967 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1968 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1969 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1970 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1971 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1972 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1973 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1974 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1975 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1976 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1977 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1978 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1979 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1980 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1981 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1982 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1983 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1984 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1985 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1986 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1987 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
1988 default:
1989 return NULL;
1990 }
1991 }
1992
1993 static const char *
1994 get_solaris_section_type (unsigned long type)
1995 {
1996 switch (type)
1997 {
1998 case 0x6fffffee: return "SUNW_ancillary";
1999 case 0x6fffffef: return "SUNW_capchain";
2000 case 0x6ffffff0: return "SUNW_capinfo";
2001 case 0x6ffffff1: return "SUNW_symsort";
2002 case 0x6ffffff2: return "SUNW_tlssort";
2003 case 0x6ffffff3: return "SUNW_LDYNSYM";
2004 case 0x6ffffff4: return "SUNW_dof";
2005 case 0x6ffffff5: return "SUNW_cap";
2006 case 0x6ffffff6: return "SUNW_SIGNATURE";
2007 case 0x6ffffff7: return "SUNW_ANNOTATE";
2008 case 0x6ffffff8: return "SUNW_DEBUGSTR";
2009 case 0x6ffffff9: return "SUNW_DEBUG";
2010 case 0x6ffffffa: return "SUNW_move";
2011 case 0x6ffffffb: return "SUNW_COMDAT";
2012 case 0x6ffffffc: return "SUNW_syminfo";
2013 case 0x6ffffffd: return "SUNW_verdef";
2014 case 0x6ffffffe: return "SUNW_verneed";
2015 case 0x6fffffff: return "SUNW_versym";
2016 case 0x70000000: return "SPARC_GOTDATA";
2017 default: return NULL;
2018 }
2019 }
2020
2021 static const char *
2022 get_alpha_dynamic_type (unsigned long type)
2023 {
2024 switch (type)
2025 {
2026 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
2027 default: return NULL;
2028 }
2029 }
2030
2031 static const char *
2032 get_score_dynamic_type (unsigned long type)
2033 {
2034 switch (type)
2035 {
2036 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
2037 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
2038 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
2039 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
2040 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
2041 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
2042 default: return NULL;
2043 }
2044 }
2045
2046 static const char *
2047 get_tic6x_dynamic_type (unsigned long type)
2048 {
2049 switch (type)
2050 {
2051 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
2052 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
2053 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
2054 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
2055 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
2056 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
2057 default: return NULL;
2058 }
2059 }
2060
2061 static const char *
2062 get_nios2_dynamic_type (unsigned long type)
2063 {
2064 switch (type)
2065 {
2066 case DT_NIOS2_GP: return "NIOS2_GP";
2067 default: return NULL;
2068 }
2069 }
2070
2071 static const char *
2072 get_solaris_dynamic_type (unsigned long type)
2073 {
2074 switch (type)
2075 {
2076 case 0x6000000d: return "SUNW_AUXILIARY";
2077 case 0x6000000e: return "SUNW_RTLDINF";
2078 case 0x6000000f: return "SUNW_FILTER";
2079 case 0x60000010: return "SUNW_CAP";
2080 case 0x60000011: return "SUNW_SYMTAB";
2081 case 0x60000012: return "SUNW_SYMSZ";
2082 case 0x60000013: return "SUNW_SORTENT";
2083 case 0x60000014: return "SUNW_SYMSORT";
2084 case 0x60000015: return "SUNW_SYMSORTSZ";
2085 case 0x60000016: return "SUNW_TLSSORT";
2086 case 0x60000017: return "SUNW_TLSSORTSZ";
2087 case 0x60000018: return "SUNW_CAPINFO";
2088 case 0x60000019: return "SUNW_STRPAD";
2089 case 0x6000001a: return "SUNW_CAPCHAIN";
2090 case 0x6000001b: return "SUNW_LDMACH";
2091 case 0x6000001d: return "SUNW_CAPCHAINENT";
2092 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2093 case 0x60000021: return "SUNW_PARENT";
2094 case 0x60000023: return "SUNW_ASLR";
2095 case 0x60000025: return "SUNW_RELAX";
2096 case 0x60000029: return "SUNW_NXHEAP";
2097 case 0x6000002b: return "SUNW_NXSTACK";
2098
2099 case 0x70000001: return "SPARC_REGISTER";
2100 case 0x7ffffffd: return "AUXILIARY";
2101 case 0x7ffffffe: return "USED";
2102 case 0x7fffffff: return "FILTER";
2103
2104 default: return NULL;
2105 }
2106 }
2107
2108 static const char *
2109 get_dynamic_type (Filedata * filedata, unsigned long type)
2110 {
2111 static char buff[64];
2112
2113 switch (type)
2114 {
2115 case DT_NULL: return "NULL";
2116 case DT_NEEDED: return "NEEDED";
2117 case DT_PLTRELSZ: return "PLTRELSZ";
2118 case DT_PLTGOT: return "PLTGOT";
2119 case DT_HASH: return "HASH";
2120 case DT_STRTAB: return "STRTAB";
2121 case DT_SYMTAB: return "SYMTAB";
2122 case DT_RELA: return "RELA";
2123 case DT_RELASZ: return "RELASZ";
2124 case DT_RELAENT: return "RELAENT";
2125 case DT_STRSZ: return "STRSZ";
2126 case DT_SYMENT: return "SYMENT";
2127 case DT_INIT: return "INIT";
2128 case DT_FINI: return "FINI";
2129 case DT_SONAME: return "SONAME";
2130 case DT_RPATH: return "RPATH";
2131 case DT_SYMBOLIC: return "SYMBOLIC";
2132 case DT_REL: return "REL";
2133 case DT_RELSZ: return "RELSZ";
2134 case DT_RELENT: return "RELENT";
2135 case DT_PLTREL: return "PLTREL";
2136 case DT_DEBUG: return "DEBUG";
2137 case DT_TEXTREL: return "TEXTREL";
2138 case DT_JMPREL: return "JMPREL";
2139 case DT_BIND_NOW: return "BIND_NOW";
2140 case DT_INIT_ARRAY: return "INIT_ARRAY";
2141 case DT_FINI_ARRAY: return "FINI_ARRAY";
2142 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
2143 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
2144 case DT_RUNPATH: return "RUNPATH";
2145 case DT_FLAGS: return "FLAGS";
2146
2147 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2148 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
2149 case DT_SYMTAB_SHNDX: return "SYMTAB_SHNDX";
2150
2151 case DT_CHECKSUM: return "CHECKSUM";
2152 case DT_PLTPADSZ: return "PLTPADSZ";
2153 case DT_MOVEENT: return "MOVEENT";
2154 case DT_MOVESZ: return "MOVESZ";
2155 case DT_FEATURE: return "FEATURE";
2156 case DT_POSFLAG_1: return "POSFLAG_1";
2157 case DT_SYMINSZ: return "SYMINSZ";
2158 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
2159
2160 case DT_ADDRRNGLO: return "ADDRRNGLO";
2161 case DT_CONFIG: return "CONFIG";
2162 case DT_DEPAUDIT: return "DEPAUDIT";
2163 case DT_AUDIT: return "AUDIT";
2164 case DT_PLTPAD: return "PLTPAD";
2165 case DT_MOVETAB: return "MOVETAB";
2166 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
2167
2168 case DT_VERSYM: return "VERSYM";
2169
2170 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
2171 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
2172 case DT_RELACOUNT: return "RELACOUNT";
2173 case DT_RELCOUNT: return "RELCOUNT";
2174 case DT_FLAGS_1: return "FLAGS_1";
2175 case DT_VERDEF: return "VERDEF";
2176 case DT_VERDEFNUM: return "VERDEFNUM";
2177 case DT_VERNEED: return "VERNEED";
2178 case DT_VERNEEDNUM: return "VERNEEDNUM";
2179
2180 case DT_AUXILIARY: return "AUXILIARY";
2181 case DT_USED: return "USED";
2182 case DT_FILTER: return "FILTER";
2183
2184 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
2185 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
2186 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
2187 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
2188 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
2189 case DT_GNU_HASH: return "GNU_HASH";
2190
2191 default:
2192 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
2193 {
2194 const char * result;
2195
2196 switch (filedata->file_header.e_machine)
2197 {
2198 case EM_AARCH64:
2199 result = get_aarch64_dynamic_type (type);
2200 break;
2201 case EM_MIPS:
2202 case EM_MIPS_RS3_LE:
2203 result = get_mips_dynamic_type (type);
2204 break;
2205 case EM_SPARCV9:
2206 result = get_sparc64_dynamic_type (type);
2207 break;
2208 case EM_PPC:
2209 result = get_ppc_dynamic_type (type);
2210 break;
2211 case EM_PPC64:
2212 result = get_ppc64_dynamic_type (type);
2213 break;
2214 case EM_IA_64:
2215 result = get_ia64_dynamic_type (type);
2216 break;
2217 case EM_ALPHA:
2218 result = get_alpha_dynamic_type (type);
2219 break;
2220 case EM_SCORE:
2221 result = get_score_dynamic_type (type);
2222 break;
2223 case EM_TI_C6000:
2224 result = get_tic6x_dynamic_type (type);
2225 break;
2226 case EM_ALTERA_NIOS2:
2227 result = get_nios2_dynamic_type (type);
2228 break;
2229 default:
2230 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2231 result = get_solaris_dynamic_type (type);
2232 else
2233 result = NULL;
2234 break;
2235 }
2236
2237 if (result != NULL)
2238 return result;
2239
2240 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2241 }
2242 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2243 || (filedata->file_header.e_machine == EM_PARISC
2244 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
2245 {
2246 const char * result;
2247
2248 switch (filedata->file_header.e_machine)
2249 {
2250 case EM_PARISC:
2251 result = get_parisc_dynamic_type (type);
2252 break;
2253 case EM_IA_64:
2254 result = get_ia64_dynamic_type (type);
2255 break;
2256 default:
2257 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2258 result = get_solaris_dynamic_type (type);
2259 else
2260 result = NULL;
2261 break;
2262 }
2263
2264 if (result != NULL)
2265 return result;
2266
2267 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2268 type);
2269 }
2270 else
2271 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2272
2273 return buff;
2274 }
2275 }
2276
2277 static char *
2278 get_file_type (unsigned e_type)
2279 {
2280 static char buff[32];
2281
2282 switch (e_type)
2283 {
2284 case ET_NONE: return _("NONE (None)");
2285 case ET_REL: return _("REL (Relocatable file)");
2286 case ET_EXEC: return _("EXEC (Executable file)");
2287 case ET_DYN: return _("DYN (Shared object file)");
2288 case ET_CORE: return _("CORE (Core file)");
2289
2290 default:
2291 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2292 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2293 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2294 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2295 else
2296 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2297 return buff;
2298 }
2299 }
2300
2301 static char *
2302 get_machine_name (unsigned e_machine)
2303 {
2304 static char buff[64]; /* XXX */
2305
2306 switch (e_machine)
2307 {
2308 /* Please keep this switch table sorted by increasing EM_ value. */
2309 /* 0 */
2310 case EM_NONE: return _("None");
2311 case EM_M32: return "WE32100";
2312 case EM_SPARC: return "Sparc";
2313 case EM_386: return "Intel 80386";
2314 case EM_68K: return "MC68000";
2315 case EM_88K: return "MC88000";
2316 case EM_IAMCU: return "Intel MCU";
2317 case EM_860: return "Intel 80860";
2318 case EM_MIPS: return "MIPS R3000";
2319 case EM_S370: return "IBM System/370";
2320 /* 10 */
2321 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
2322 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
2323 case EM_PARISC: return "HPPA";
2324 case EM_VPP550: return "Fujitsu VPP500";
2325 case EM_SPARC32PLUS: return "Sparc v8+" ;
2326 case EM_960: return "Intel 80960";
2327 case EM_PPC: return "PowerPC";
2328 /* 20 */
2329 case EM_PPC64: return "PowerPC64";
2330 case EM_S390_OLD:
2331 case EM_S390: return "IBM S/390";
2332 case EM_SPU: return "SPU";
2333 /* 30 */
2334 case EM_V800: return "Renesas V850 (using RH850 ABI)";
2335 case EM_FR20: return "Fujitsu FR20";
2336 case EM_RH32: return "TRW RH32";
2337 case EM_MCORE: return "MCORE";
2338 /* 40 */
2339 case EM_ARM: return "ARM";
2340 case EM_OLD_ALPHA: return "Digital Alpha (old)";
2341 case EM_SH: return "Renesas / SuperH SH";
2342 case EM_SPARCV9: return "Sparc v9";
2343 case EM_TRICORE: return "Siemens Tricore";
2344 case EM_ARC: return "ARC";
2345 case EM_H8_300: return "Renesas H8/300";
2346 case EM_H8_300H: return "Renesas H8/300H";
2347 case EM_H8S: return "Renesas H8S";
2348 case EM_H8_500: return "Renesas H8/500";
2349 /* 50 */
2350 case EM_IA_64: return "Intel IA-64";
2351 case EM_MIPS_X: return "Stanford MIPS-X";
2352 case EM_COLDFIRE: return "Motorola Coldfire";
2353 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
2354 case EM_MMA: return "Fujitsu Multimedia Accelerator";
2355 case EM_PCP: return "Siemens PCP";
2356 case EM_NCPU: return "Sony nCPU embedded RISC processor";
2357 case EM_NDR1: return "Denso NDR1 microprocesspr";
2358 case EM_STARCORE: return "Motorola Star*Core processor";
2359 case EM_ME16: return "Toyota ME16 processor";
2360 /* 60 */
2361 case EM_ST100: return "STMicroelectronics ST100 processor";
2362 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
2363 case EM_X86_64: return "Advanced Micro Devices X86-64";
2364 case EM_PDSP: return "Sony DSP processor";
2365 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
2366 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
2367 case EM_FX66: return "Siemens FX66 microcontroller";
2368 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2369 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
2370 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
2371 /* 70 */
2372 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
2373 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
2374 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
2375 case EM_SVX: return "Silicon Graphics SVx";
2376 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2377 case EM_VAX: return "Digital VAX";
2378 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
2379 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2380 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2381 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
2382 /* 80 */
2383 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
2384 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
2385 case EM_PRISM: return "Vitesse Prism";
2386 case EM_AVR_OLD:
2387 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
2388 case EM_CYGNUS_FR30:
2389 case EM_FR30: return "Fujitsu FR30";
2390 case EM_CYGNUS_D10V:
2391 case EM_D10V: return "d10v";
2392 case EM_CYGNUS_D30V:
2393 case EM_D30V: return "d30v";
2394 case EM_CYGNUS_V850:
2395 case EM_V850: return "Renesas V850";
2396 case EM_CYGNUS_M32R:
2397 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2398 case EM_CYGNUS_MN10300:
2399 case EM_MN10300: return "mn10300";
2400 /* 90 */
2401 case EM_CYGNUS_MN10200:
2402 case EM_MN10200: return "mn10200";
2403 case EM_PJ: return "picoJava";
2404 case EM_OR1K: return "OpenRISC 1000";
2405 case EM_ARC_COMPACT: return "ARCompact";
2406 case EM_XTENSA_OLD:
2407 case EM_XTENSA: return "Tensilica Xtensa Processor";
2408 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2409 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2410 case EM_NS32K: return "National Semiconductor 32000 series";
2411 case EM_TPC: return "Tenor Network TPC processor";
2412 case EM_SNP1K: return "Trebia SNP 1000 processor";
2413 /* 100 */
2414 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2415 case EM_IP2K_OLD:
2416 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
2417 case EM_MAX: return "MAX Processor";
2418 case EM_CR: return "National Semiconductor CompactRISC";
2419 case EM_F2MC16: return "Fujitsu F2MC16";
2420 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
2421 case EM_BLACKFIN: return "Analog Devices Blackfin";
2422 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2423 case EM_SEP: return "Sharp embedded microprocessor";
2424 case EM_ARCA: return "Arca RISC microprocessor";
2425 /* 110 */
2426 case EM_UNICORE: return "Unicore";
2427 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2428 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
2429 case EM_ALTERA_NIOS2: return "Altera Nios II";
2430 case EM_CRX: return "National Semiconductor CRX microprocessor";
2431 case EM_XGATE: return "Motorola XGATE embedded processor";
2432 case EM_C166:
2433 case EM_XC16X: return "Infineon Technologies xc16x";
2434 case EM_M16C: return "Renesas M16C series microprocessors";
2435 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2436 case EM_CE: return "Freescale Communication Engine RISC core";
2437 /* 120 */
2438 case EM_M32C: return "Renesas M32c";
2439 /* 130 */
2440 case EM_TSK3000: return "Altium TSK3000 core";
2441 case EM_RS08: return "Freescale RS08 embedded processor";
2442 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2443 case EM_SCORE: return "SUNPLUS S+Core";
2444 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2445 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2446 case EM_LATTICEMICO32: return "Lattice Mico32";
2447 case EM_SE_C17: return "Seiko Epson C17 family";
2448 /* 140 */
2449 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2450 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2451 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2452 case EM_TI_PRU: return "TI PRU I/O processor";
2453 /* 160 */
2454 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2455 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2456 case EM_R32C: return "Renesas R32C series microprocessors";
2457 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2458 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2459 case EM_8051: return "Intel 8051 and variants";
2460 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2461 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2462 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2463 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2464 /* 170 */
2465 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2466 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2467 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
2468 case EM_RX: return "Renesas RX";
2469 case EM_METAG: return "Imagination Technologies Meta processor architecture";
2470 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2471 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2472 case EM_CR16:
2473 case EM_MICROBLAZE:
2474 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
2475 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2476 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2477 /* 180 */
2478 case EM_L1OM: return "Intel L1OM";
2479 case EM_K1OM: return "Intel K1OM";
2480 case EM_INTEL182: return "Intel (reserved)";
2481 case EM_AARCH64: return "AArch64";
2482 case EM_ARM184: return "ARM (reserved)";
2483 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor";
2484 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2485 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2486 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
2487 /* 190 */
2488 case EM_CUDA: return "NVIDIA CUDA architecture";
2489 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
2490 case EM_CLOUDSHIELD: return "CloudShield architecture family";
2491 case EM_COREA_1ST: return "KIPO-KAIST Core-A 1st generation processor family";
2492 case EM_COREA_2ND: return "KIPO-KAIST Core-A 2nd generation processor family";
2493 case EM_ARC_COMPACT2: return "ARCv2";
2494 case EM_OPEN8: return "Open8 8-bit RISC soft processor core";
2495 case EM_RL78: return "Renesas RL78";
2496 case EM_VIDEOCORE5: return "Broadcom VideoCore V processor";
2497 case EM_78K0R: return "Renesas 78K0R";
2498 /* 200 */
2499 case EM_56800EX: return "Freescale 56800EX Digital Signal Controller (DSC)";
2500 case EM_BA1: return "Beyond BA1 CPU architecture";
2501 case EM_BA2: return "Beyond BA2 CPU architecture";
2502 case EM_XCORE: return "XMOS xCORE processor family";
2503 case EM_MCHP_PIC: return "Microchip 8-bit PIC(r) family";
2504 /* 210 */
2505 case EM_KM32: return "KM211 KM32 32-bit processor";
2506 case EM_KMX32: return "KM211 KMX32 32-bit processor";
2507 case EM_KMX16: return "KM211 KMX16 16-bit processor";
2508 case EM_KMX8: return "KM211 KMX8 8-bit processor";
2509 case EM_KVARC: return "KM211 KVARC processor";
2510 case EM_CDP: return "Paneve CDP architecture family";
2511 case EM_COGE: return "Cognitive Smart Memory Processor";
2512 case EM_COOL: return "Bluechip Systems CoolEngine";
2513 case EM_NORC: return "Nanoradio Optimized RISC";
2514 case EM_CSR_KALIMBA: return "CSR Kalimba architecture family";
2515 /* 220 */
2516 case EM_Z80: return "Zilog Z80";
2517 case EM_VISIUM: return "CDS VISIUMcore processor";
2518 case EM_FT32: return "FTDI Chip FT32";
2519 case EM_MOXIE: return "Moxie";
2520 case EM_AMDGPU: return "AMD GPU";
2521 case EM_RISCV: return "RISC-V";
2522 case EM_LANAI: return "Lanai 32-bit processor";
2523 case EM_BPF: return "Linux BPF";
2524 case EM_NFP: return "Netronome Flow Processor";
2525
2526 /* Large numbers... */
2527 case EM_MT: return "Morpho Techologies MT processor";
2528 case EM_ALPHA: return "Alpha";
2529 case EM_WEBASSEMBLY: return "Web Assembly";
2530 case EM_DLX: return "OpenDLX";
2531 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
2532 case EM_IQ2000: return "Vitesse IQ2000";
2533 case EM_M32C_OLD:
2534 case EM_NIOS32: return "Altera Nios";
2535 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
2536 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
2537 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2538 case EM_S12Z: return "Freescale S12Z";
2539 case EM_CSKY: return "C-SKY";
2540
2541 default:
2542 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2543 return buff;
2544 }
2545 }
2546
2547 static void
2548 decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
2549 {
2550 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2551 other compilers don't a specific architecture type in the e_flags, and
2552 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2553 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2554 architectures.
2555
2556 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2557 but also sets a specific architecture type in the e_flags field.
2558
2559 However, when decoding the flags we don't worry if we see an
2560 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2561 ARCEM architecture type. */
2562
2563 switch (e_flags & EF_ARC_MACH_MSK)
2564 {
2565 /* We only expect these to occur for EM_ARC_COMPACT2. */
2566 case EF_ARC_CPU_ARCV2EM:
2567 strcat (buf, ", ARC EM");
2568 break;
2569 case EF_ARC_CPU_ARCV2HS:
2570 strcat (buf, ", ARC HS");
2571 break;
2572
2573 /* We only expect these to occur for EM_ARC_COMPACT. */
2574 case E_ARC_MACH_ARC600:
2575 strcat (buf, ", ARC600");
2576 break;
2577 case E_ARC_MACH_ARC601:
2578 strcat (buf, ", ARC601");
2579 break;
2580 case E_ARC_MACH_ARC700:
2581 strcat (buf, ", ARC700");
2582 break;
2583
2584 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2585 new ELF with new architecture being read by an old version of
2586 readelf, or (c) An ELF built with non-GNU compiler that does not
2587 set the architecture in the e_flags. */
2588 default:
2589 if (e_machine == EM_ARC_COMPACT)
2590 strcat (buf, ", Unknown ARCompact");
2591 else
2592 strcat (buf, ", Unknown ARC");
2593 break;
2594 }
2595
2596 switch (e_flags & EF_ARC_OSABI_MSK)
2597 {
2598 case E_ARC_OSABI_ORIG:
2599 strcat (buf, ", (ABI:legacy)");
2600 break;
2601 case E_ARC_OSABI_V2:
2602 strcat (buf, ", (ABI:v2)");
2603 break;
2604 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2605 case E_ARC_OSABI_V3:
2606 strcat (buf, ", v3 no-legacy-syscalls ABI");
2607 break;
2608 case E_ARC_OSABI_V4:
2609 strcat (buf, ", v4 ABI");
2610 break;
2611 default:
2612 strcat (buf, ", unrecognised ARC OSABI flag");
2613 break;
2614 }
2615 }
2616
2617 static void
2618 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2619 {
2620 unsigned eabi;
2621 bfd_boolean unknown = FALSE;
2622
2623 eabi = EF_ARM_EABI_VERSION (e_flags);
2624 e_flags &= ~ EF_ARM_EABIMASK;
2625
2626 /* Handle "generic" ARM flags. */
2627 if (e_flags & EF_ARM_RELEXEC)
2628 {
2629 strcat (buf, ", relocatable executable");
2630 e_flags &= ~ EF_ARM_RELEXEC;
2631 }
2632
2633 if (e_flags & EF_ARM_PIC)
2634 {
2635 strcat (buf, ", position independent");
2636 e_flags &= ~ EF_ARM_PIC;
2637 }
2638
2639 /* Now handle EABI specific flags. */
2640 switch (eabi)
2641 {
2642 default:
2643 strcat (buf, ", <unrecognized EABI>");
2644 if (e_flags)
2645 unknown = TRUE;
2646 break;
2647
2648 case EF_ARM_EABI_VER1:
2649 strcat (buf, ", Version1 EABI");
2650 while (e_flags)
2651 {
2652 unsigned flag;
2653
2654 /* Process flags one bit at a time. */
2655 flag = e_flags & - e_flags;
2656 e_flags &= ~ flag;
2657
2658 switch (flag)
2659 {
2660 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2661 strcat (buf, ", sorted symbol tables");
2662 break;
2663
2664 default:
2665 unknown = TRUE;
2666 break;
2667 }
2668 }
2669 break;
2670
2671 case EF_ARM_EABI_VER2:
2672 strcat (buf, ", Version2 EABI");
2673 while (e_flags)
2674 {
2675 unsigned flag;
2676
2677 /* Process flags one bit at a time. */
2678 flag = e_flags & - e_flags;
2679 e_flags &= ~ flag;
2680
2681 switch (flag)
2682 {
2683 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2684 strcat (buf, ", sorted symbol tables");
2685 break;
2686
2687 case EF_ARM_DYNSYMSUSESEGIDX:
2688 strcat (buf, ", dynamic symbols use segment index");
2689 break;
2690
2691 case EF_ARM_MAPSYMSFIRST:
2692 strcat (buf, ", mapping symbols precede others");
2693 break;
2694
2695 default:
2696 unknown = TRUE;
2697 break;
2698 }
2699 }
2700 break;
2701
2702 case EF_ARM_EABI_VER3:
2703 strcat (buf, ", Version3 EABI");
2704 break;
2705
2706 case EF_ARM_EABI_VER4:
2707 strcat (buf, ", Version4 EABI");
2708 while (e_flags)
2709 {
2710 unsigned flag;
2711
2712 /* Process flags one bit at a time. */
2713 flag = e_flags & - e_flags;
2714 e_flags &= ~ flag;
2715
2716 switch (flag)
2717 {
2718 case EF_ARM_BE8:
2719 strcat (buf, ", BE8");
2720 break;
2721
2722 case EF_ARM_LE8:
2723 strcat (buf, ", LE8");
2724 break;
2725
2726 default:
2727 unknown = TRUE;
2728 break;
2729 }
2730 }
2731 break;
2732
2733 case EF_ARM_EABI_VER5:
2734 strcat (buf, ", Version5 EABI");
2735 while (e_flags)
2736 {
2737 unsigned flag;
2738
2739 /* Process flags one bit at a time. */
2740 flag = e_flags & - e_flags;
2741 e_flags &= ~ flag;
2742
2743 switch (flag)
2744 {
2745 case EF_ARM_BE8:
2746 strcat (buf, ", BE8");
2747 break;
2748
2749 case EF_ARM_LE8:
2750 strcat (buf, ", LE8");
2751 break;
2752
2753 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2754 strcat (buf, ", soft-float ABI");
2755 break;
2756
2757 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2758 strcat (buf, ", hard-float ABI");
2759 break;
2760
2761 default:
2762 unknown = TRUE;
2763 break;
2764 }
2765 }
2766 break;
2767
2768 case EF_ARM_EABI_UNKNOWN:
2769 strcat (buf, ", GNU EABI");
2770 while (e_flags)
2771 {
2772 unsigned flag;
2773
2774 /* Process flags one bit at a time. */
2775 flag = e_flags & - e_flags;
2776 e_flags &= ~ flag;
2777
2778 switch (flag)
2779 {
2780 case EF_ARM_INTERWORK:
2781 strcat (buf, ", interworking enabled");
2782 break;
2783
2784 case EF_ARM_APCS_26:
2785 strcat (buf, ", uses APCS/26");
2786 break;
2787
2788 case EF_ARM_APCS_FLOAT:
2789 strcat (buf, ", uses APCS/float");
2790 break;
2791
2792 case EF_ARM_PIC:
2793 strcat (buf, ", position independent");
2794 break;
2795
2796 case EF_ARM_ALIGN8:
2797 strcat (buf, ", 8 bit structure alignment");
2798 break;
2799
2800 case EF_ARM_NEW_ABI:
2801 strcat (buf, ", uses new ABI");
2802 break;
2803
2804 case EF_ARM_OLD_ABI:
2805 strcat (buf, ", uses old ABI");
2806 break;
2807
2808 case EF_ARM_SOFT_FLOAT:
2809 strcat (buf, ", software FP");
2810 break;
2811
2812 case EF_ARM_VFP_FLOAT:
2813 strcat (buf, ", VFP");
2814 break;
2815
2816 case EF_ARM_MAVERICK_FLOAT:
2817 strcat (buf, ", Maverick FP");
2818 break;
2819
2820 default:
2821 unknown = TRUE;
2822 break;
2823 }
2824 }
2825 }
2826
2827 if (unknown)
2828 strcat (buf,_(", <unknown>"));
2829 }
2830
2831 static void
2832 decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2833 {
2834 --size; /* Leave space for null terminator. */
2835
2836 switch (e_flags & EF_AVR_MACH)
2837 {
2838 case E_AVR_MACH_AVR1:
2839 strncat (buf, ", avr:1", size);
2840 break;
2841 case E_AVR_MACH_AVR2:
2842 strncat (buf, ", avr:2", size);
2843 break;
2844 case E_AVR_MACH_AVR25:
2845 strncat (buf, ", avr:25", size);
2846 break;
2847 case E_AVR_MACH_AVR3:
2848 strncat (buf, ", avr:3", size);
2849 break;
2850 case E_AVR_MACH_AVR31:
2851 strncat (buf, ", avr:31", size);
2852 break;
2853 case E_AVR_MACH_AVR35:
2854 strncat (buf, ", avr:35", size);
2855 break;
2856 case E_AVR_MACH_AVR4:
2857 strncat (buf, ", avr:4", size);
2858 break;
2859 case E_AVR_MACH_AVR5:
2860 strncat (buf, ", avr:5", size);
2861 break;
2862 case E_AVR_MACH_AVR51:
2863 strncat (buf, ", avr:51", size);
2864 break;
2865 case E_AVR_MACH_AVR6:
2866 strncat (buf, ", avr:6", size);
2867 break;
2868 case E_AVR_MACH_AVRTINY:
2869 strncat (buf, ", avr:100", size);
2870 break;
2871 case E_AVR_MACH_XMEGA1:
2872 strncat (buf, ", avr:101", size);
2873 break;
2874 case E_AVR_MACH_XMEGA2:
2875 strncat (buf, ", avr:102", size);
2876 break;
2877 case E_AVR_MACH_XMEGA3:
2878 strncat (buf, ", avr:103", size);
2879 break;
2880 case E_AVR_MACH_XMEGA4:
2881 strncat (buf, ", avr:104", size);
2882 break;
2883 case E_AVR_MACH_XMEGA5:
2884 strncat (buf, ", avr:105", size);
2885 break;
2886 case E_AVR_MACH_XMEGA6:
2887 strncat (buf, ", avr:106", size);
2888 break;
2889 case E_AVR_MACH_XMEGA7:
2890 strncat (buf, ", avr:107", size);
2891 break;
2892 default:
2893 strncat (buf, ", avr:<unknown>", size);
2894 break;
2895 }
2896
2897 size -= strlen (buf);
2898 if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2899 strncat (buf, ", link-relax", size);
2900 }
2901
2902 static void
2903 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2904 {
2905 unsigned abi;
2906 unsigned arch;
2907 unsigned config;
2908 unsigned version;
2909 bfd_boolean has_fpu = FALSE;
2910 unsigned int r = 0;
2911
2912 static const char *ABI_STRINGS[] =
2913 {
2914 "ABI v0", /* use r5 as return register; only used in N1213HC */
2915 "ABI v1", /* use r0 as return register */
2916 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2917 "ABI v2fp", /* for FPU */
2918 "AABI",
2919 "ABI2 FP+"
2920 };
2921 static const char *VER_STRINGS[] =
2922 {
2923 "Andes ELF V1.3 or older",
2924 "Andes ELF V1.3.1",
2925 "Andes ELF V1.4"
2926 };
2927 static const char *ARCH_STRINGS[] =
2928 {
2929 "",
2930 "Andes Star v1.0",
2931 "Andes Star v2.0",
2932 "Andes Star v3.0",
2933 "Andes Star v3.0m"
2934 };
2935
2936 abi = EF_NDS_ABI & e_flags;
2937 arch = EF_NDS_ARCH & e_flags;
2938 config = EF_NDS_INST & e_flags;
2939 version = EF_NDS32_ELF_VERSION & e_flags;
2940
2941 memset (buf, 0, size);
2942
2943 switch (abi)
2944 {
2945 case E_NDS_ABI_V0:
2946 case E_NDS_ABI_V1:
2947 case E_NDS_ABI_V2:
2948 case E_NDS_ABI_V2FP:
2949 case E_NDS_ABI_AABI:
2950 case E_NDS_ABI_V2FP_PLUS:
2951 /* In case there are holes in the array. */
2952 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2953 break;
2954
2955 default:
2956 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2957 break;
2958 }
2959
2960 switch (version)
2961 {
2962 case E_NDS32_ELF_VER_1_2:
2963 case E_NDS32_ELF_VER_1_3:
2964 case E_NDS32_ELF_VER_1_4:
2965 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2966 break;
2967
2968 default:
2969 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2970 break;
2971 }
2972
2973 if (E_NDS_ABI_V0 == abi)
2974 {
2975 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2976 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2977 if (arch == E_NDS_ARCH_STAR_V1_0)
2978 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2979 return;
2980 }
2981
2982 switch (arch)
2983 {
2984 case E_NDS_ARCH_STAR_V1_0:
2985 case E_NDS_ARCH_STAR_V2_0:
2986 case E_NDS_ARCH_STAR_V3_0:
2987 case E_NDS_ARCH_STAR_V3_M:
2988 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2989 break;
2990
2991 default:
2992 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2993 /* ARCH version determines how the e_flags are interpreted.
2994 If it is unknown, we cannot proceed. */
2995 return;
2996 }
2997
2998 /* Newer ABI; Now handle architecture specific flags. */
2999 if (arch == E_NDS_ARCH_STAR_V1_0)
3000 {
3001 if (config & E_NDS32_HAS_MFUSR_PC_INST)
3002 r += snprintf (buf + r, size -r, ", MFUSR_PC");
3003
3004 if (!(config & E_NDS32_HAS_NO_MAC_INST))
3005 r += snprintf (buf + r, size -r, ", MAC");
3006
3007 if (config & E_NDS32_HAS_DIV_INST)
3008 r += snprintf (buf + r, size -r, ", DIV");
3009
3010 if (config & E_NDS32_HAS_16BIT_INST)
3011 r += snprintf (buf + r, size -r, ", 16b");
3012 }
3013 else
3014 {
3015 if (config & E_NDS32_HAS_MFUSR_PC_INST)
3016 {
3017 if (version <= E_NDS32_ELF_VER_1_3)
3018 r += snprintf (buf + r, size -r, ", [B8]");
3019 else
3020 r += snprintf (buf + r, size -r, ", EX9");
3021 }
3022
3023 if (config & E_NDS32_HAS_MAC_DX_INST)
3024 r += snprintf (buf + r, size -r, ", MAC_DX");
3025
3026 if (config & E_NDS32_HAS_DIV_DX_INST)
3027 r += snprintf (buf + r, size -r, ", DIV_DX");
3028
3029 if (config & E_NDS32_HAS_16BIT_INST)
3030 {
3031 if (version <= E_NDS32_ELF_VER_1_3)
3032 r += snprintf (buf + r, size -r, ", 16b");
3033 else
3034 r += snprintf (buf + r, size -r, ", IFC");
3035 }
3036 }
3037
3038 if (config & E_NDS32_HAS_EXT_INST)
3039 r += snprintf (buf + r, size -r, ", PERF1");
3040
3041 if (config & E_NDS32_HAS_EXT2_INST)
3042 r += snprintf (buf + r, size -r, ", PERF2");
3043
3044 if (config & E_NDS32_HAS_FPU_INST)
3045 {
3046 has_fpu = TRUE;
3047 r += snprintf (buf + r, size -r, ", FPU_SP");
3048 }
3049
3050 if (config & E_NDS32_HAS_FPU_DP_INST)
3051 {
3052 has_fpu = TRUE;
3053 r += snprintf (buf + r, size -r, ", FPU_DP");
3054 }
3055
3056 if (config & E_NDS32_HAS_FPU_MAC_INST)
3057 {
3058 has_fpu = TRUE;
3059 r += snprintf (buf + r, size -r, ", FPU_MAC");
3060 }
3061
3062 if (has_fpu)
3063 {
3064 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
3065 {
3066 case E_NDS32_FPU_REG_8SP_4DP:
3067 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
3068 break;
3069 case E_NDS32_FPU_REG_16SP_8DP:
3070 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
3071 break;
3072 case E_NDS32_FPU_REG_32SP_16DP:
3073 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
3074 break;
3075 case E_NDS32_FPU_REG_32SP_32DP:
3076 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
3077 break;
3078 }
3079 }
3080
3081 if (config & E_NDS32_HAS_AUDIO_INST)
3082 r += snprintf (buf + r, size -r, ", AUDIO");
3083
3084 if (config & E_NDS32_HAS_STRING_INST)
3085 r += snprintf (buf + r, size -r, ", STR");
3086
3087 if (config & E_NDS32_HAS_REDUCED_REGS)
3088 r += snprintf (buf + r, size -r, ", 16REG");
3089
3090 if (config & E_NDS32_HAS_VIDEO_INST)
3091 {
3092 if (version <= E_NDS32_ELF_VER_1_3)
3093 r += snprintf (buf + r, size -r, ", VIDEO");
3094 else
3095 r += snprintf (buf + r, size -r, ", SATURATION");
3096 }
3097
3098 if (config & E_NDS32_HAS_ENCRIPT_INST)
3099 r += snprintf (buf + r, size -r, ", ENCRP");
3100
3101 if (config & E_NDS32_HAS_L2C_INST)
3102 r += snprintf (buf + r, size -r, ", L2C");
3103 }
3104
3105 static char *
3106 get_machine_flags (Filedata * filedata, unsigned e_flags, unsigned e_machine)
3107 {
3108 static char buf[1024];
3109
3110 buf[0] = '\0';
3111
3112 if (e_flags)
3113 {
3114 switch (e_machine)
3115 {
3116 default:
3117 break;
3118
3119 case EM_ARC_COMPACT2:
3120 case EM_ARC_COMPACT:
3121 decode_ARC_machine_flags (e_flags, e_machine, buf);
3122 break;
3123
3124 case EM_ARM:
3125 decode_ARM_machine_flags (e_flags, buf);
3126 break;
3127
3128 case EM_AVR:
3129 decode_AVR_machine_flags (e_flags, buf, sizeof buf);
3130 break;
3131
3132 case EM_BLACKFIN:
3133 if (e_flags & EF_BFIN_PIC)
3134 strcat (buf, ", PIC");
3135
3136 if (e_flags & EF_BFIN_FDPIC)
3137 strcat (buf, ", FDPIC");
3138
3139 if (e_flags & EF_BFIN_CODE_IN_L1)
3140 strcat (buf, ", code in L1");
3141
3142 if (e_flags & EF_BFIN_DATA_IN_L1)
3143 strcat (buf, ", data in L1");
3144
3145 break;
3146
3147 case EM_CYGNUS_FRV:
3148 switch (e_flags & EF_FRV_CPU_MASK)
3149 {
3150 case EF_FRV_CPU_GENERIC:
3151 break;
3152
3153 default:
3154 strcat (buf, ", fr???");
3155 break;
3156
3157 case EF_FRV_CPU_FR300:
3158 strcat (buf, ", fr300");
3159 break;
3160
3161 case EF_FRV_CPU_FR400:
3162 strcat (buf, ", fr400");
3163 break;
3164 case EF_FRV_CPU_FR405:
3165 strcat (buf, ", fr405");
3166 break;
3167
3168 case EF_FRV_CPU_FR450:
3169 strcat (buf, ", fr450");
3170 break;
3171
3172 case EF_FRV_CPU_FR500:
3173 strcat (buf, ", fr500");
3174 break;
3175 case EF_FRV_CPU_FR550:
3176 strcat (buf, ", fr550");
3177 break;
3178
3179 case EF_FRV_CPU_SIMPLE:
3180 strcat (buf, ", simple");
3181 break;
3182 case EF_FRV_CPU_TOMCAT:
3183 strcat (buf, ", tomcat");
3184 break;
3185 }
3186 break;
3187
3188 case EM_68K:
3189 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
3190 strcat (buf, ", m68000");
3191 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3192 strcat (buf, ", cpu32");
3193 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
3194 strcat (buf, ", fido_a");
3195 else
3196 {
3197 char const * isa = _("unknown");
3198 char const * mac = _("unknown mac");
3199 char const * additional = NULL;
3200
3201 switch (e_flags & EF_M68K_CF_ISA_MASK)
3202 {
3203 case EF_M68K_CF_ISA_A_NODIV:
3204 isa = "A";
3205 additional = ", nodiv";
3206 break;
3207 case EF_M68K_CF_ISA_A:
3208 isa = "A";
3209 break;
3210 case EF_M68K_CF_ISA_A_PLUS:
3211 isa = "A+";
3212 break;
3213 case EF_M68K_CF_ISA_B_NOUSP:
3214 isa = "B";
3215 additional = ", nousp";
3216 break;
3217 case EF_M68K_CF_ISA_B:
3218 isa = "B";
3219 break;
3220 case EF_M68K_CF_ISA_C:
3221 isa = "C";
3222 break;
3223 case EF_M68K_CF_ISA_C_NODIV:
3224 isa = "C";
3225 additional = ", nodiv";
3226 break;
3227 }
3228 strcat (buf, ", cf, isa ");
3229 strcat (buf, isa);
3230 if (additional)
3231 strcat (buf, additional);
3232 if (e_flags & EF_M68K_CF_FLOAT)
3233 strcat (buf, ", float");
3234 switch (e_flags & EF_M68K_CF_MAC_MASK)
3235 {
3236 case 0:
3237 mac = NULL;
3238 break;
3239 case EF_M68K_CF_MAC:
3240 mac = "mac";
3241 break;
3242 case EF_M68K_CF_EMAC:
3243 mac = "emac";
3244 break;
3245 case EF_M68K_CF_EMAC_B:
3246 mac = "emac_b";
3247 break;
3248 }
3249 if (mac)
3250 {
3251 strcat (buf, ", ");
3252 strcat (buf, mac);
3253 }
3254 }
3255 break;
3256
3257 case EM_AMDGPU:
3258 switch (e_flags & EF_AMDGPU_MACH)
3259 {
3260 case EF_AMDGPU_MACH_AMDGCN_GFX801 : strcat (buf, ", gfx801"); break;
3261 case EF_AMDGPU_MACH_AMDGCN_GFX802 : strcat (buf, ", gfx802"); break;
3262 case EF_AMDGPU_MACH_AMDGCN_GFX803 : strcat (buf, ", gfx803"); break;
3263 case EF_AMDGPU_MACH_AMDGCN_GFX810 : strcat (buf, ", gfx810"); break;
3264 case EF_AMDGPU_MACH_AMDGCN_GFX900 : strcat (buf, ", gfx900"); break;
3265 case EF_AMDGPU_MACH_AMDGCN_GFX902 : strcat (buf, ", gfx902"); break;
3266 case EF_AMDGPU_MACH_AMDGCN_GFX904 : strcat (buf, ", gfx904"); break;
3267 case EF_AMDGPU_MACH_AMDGCN_GFX906 : strcat (buf, ", gfx906"); break;
3268 case EF_AMDGPU_MACH_AMDGCN_GFX908 : strcat (buf, ", gfx908"); break;
3269 case EF_AMDGPU_MACH_AMDGCN_GFX909 : strcat (buf, ", gfx909"); break;
3270 default: strcat (buf, _(", <unknown AMDGPU gpu type>")); break;
3271 }
3272
3273 if (e_flags & ~ EF_AMDGPU_MACH)
3274 sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3275 e_flags & ~ EF_AMDGPU_MACH);
3276 break;
3277
3278 case EM_CYGNUS_MEP:
3279 switch (e_flags & EF_MEP_CPU_MASK)
3280 {
3281 case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
3282 case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
3283 case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
3284 case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
3285 case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
3286 case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
3287 default: strcat (buf, _(", <unknown MeP cpu type>")); break;
3288 }
3289
3290 switch (e_flags & EF_MEP_COP_MASK)
3291 {
3292 case EF_MEP_COP_NONE: break;
3293 case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
3294 case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
3295 case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
3296 case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
3297 default: strcat (buf, _("<unknown MeP copro type>")); break;
3298 }
3299
3300 if (e_flags & EF_MEP_LIBRARY)
3301 strcat (buf, ", Built for Library");
3302
3303 if (e_flags & EF_MEP_INDEX_MASK)
3304 sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3305 e_flags & EF_MEP_INDEX_MASK);
3306
3307 if (e_flags & ~ EF_MEP_ALL_FLAGS)
3308 sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3309 e_flags & ~ EF_MEP_ALL_FLAGS);
3310 break;
3311
3312 case EM_PPC:
3313 if (e_flags & EF_PPC_EMB)
3314 strcat (buf, ", emb");
3315
3316 if (e_flags & EF_PPC_RELOCATABLE)
3317 strcat (buf, _(", relocatable"));
3318
3319 if (e_flags & EF_PPC_RELOCATABLE_LIB)
3320 strcat (buf, _(", relocatable-lib"));
3321 break;
3322
3323 case EM_PPC64:
3324 if (e_flags & EF_PPC64_ABI)
3325 {
3326 char abi[] = ", abiv0";
3327
3328 abi[6] += e_flags & EF_PPC64_ABI;
3329 strcat (buf, abi);
3330 }
3331 break;
3332
3333 case EM_V800:
3334 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3335 strcat (buf, ", RH850 ABI");
3336
3337 if (e_flags & EF_V800_850E3)
3338 strcat (buf, ", V3 architecture");
3339
3340 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3341 strcat (buf, ", FPU not used");
3342
3343 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3344 strcat (buf, ", regmode: COMMON");
3345
3346 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3347 strcat (buf, ", r4 not used");
3348
3349 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3350 strcat (buf, ", r30 not used");
3351
3352 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3353 strcat (buf, ", r5 not used");
3354
3355 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3356 strcat (buf, ", r2 not used");
3357
3358 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3359 {
3360 switch (e_flags & - e_flags)
3361 {
3362 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3363 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
3364 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3365 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
3366 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3367 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3368 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3369 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3370 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3371 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3372 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3373 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3374 default: break;
3375 }
3376 }
3377 break;
3378
3379 case EM_V850:
3380 case EM_CYGNUS_V850:
3381 switch (e_flags & EF_V850_ARCH)
3382 {
3383 case E_V850E3V5_ARCH:
3384 strcat (buf, ", v850e3v5");
3385 break;
3386 case E_V850E2V3_ARCH:
3387 strcat (buf, ", v850e2v3");
3388 break;
3389 case E_V850E2_ARCH:
3390 strcat (buf, ", v850e2");
3391 break;
3392 case E_V850E1_ARCH:
3393 strcat (buf, ", v850e1");
3394 break;
3395 case E_V850E_ARCH:
3396 strcat (buf, ", v850e");
3397 break;
3398 case E_V850_ARCH:
3399 strcat (buf, ", v850");
3400 break;
3401 default:
3402 strcat (buf, _(", unknown v850 architecture variant"));
3403 break;
3404 }
3405 break;
3406
3407 case EM_M32R:
3408 case EM_CYGNUS_M32R:
3409 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3410 strcat (buf, ", m32r");
3411 break;
3412
3413 case EM_MIPS:
3414 case EM_MIPS_RS3_LE:
3415 if (e_flags & EF_MIPS_NOREORDER)
3416 strcat (buf, ", noreorder");
3417
3418 if (e_flags & EF_MIPS_PIC)
3419 strcat (buf, ", pic");
3420
3421 if (e_flags & EF_MIPS_CPIC)
3422 strcat (buf, ", cpic");
3423
3424 if (e_flags & EF_MIPS_UCODE)
3425 strcat (buf, ", ugen_reserved");
3426
3427 if (e_flags & EF_MIPS_ABI2)
3428 strcat (buf, ", abi2");
3429
3430 if (e_flags & EF_MIPS_OPTIONS_FIRST)
3431 strcat (buf, ", odk first");
3432
3433 if (e_flags & EF_MIPS_32BITMODE)
3434 strcat (buf, ", 32bitmode");
3435
3436 if (e_flags & EF_MIPS_NAN2008)
3437 strcat (buf, ", nan2008");
3438
3439 if (e_flags & EF_MIPS_FP64)
3440 strcat (buf, ", fp64");
3441
3442 switch ((e_flags & EF_MIPS_MACH))
3443 {
3444 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3445 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3446 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3447 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3448 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3449 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3450 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3451 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3452 case E_MIPS_MACH_5900: strcat (buf, ", 5900"); break;
3453 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
3454 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3455 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3456 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3457 case E_MIPS_MACH_GS464: strcat (buf, ", gs464"); break;
3458 case E_MIPS_MACH_GS464E: strcat (buf, ", gs464e"); break;
3459 case E_MIPS_MACH_GS264E: strcat (buf, ", gs264e"); break;
3460 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3461 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3462 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3463 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
3464 case E_MIPS_MACH_IAMR2: strcat (buf, ", interaptiv-mr2"); break;
3465 case 0:
3466 /* We simply ignore the field in this case to avoid confusion:
3467 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3468 extension. */
3469 break;
3470 default: strcat (buf, _(", unknown CPU")); break;
3471 }
3472
3473 switch ((e_flags & EF_MIPS_ABI))
3474 {
3475 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3476 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3477 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3478 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3479 case 0:
3480 /* We simply ignore the field in this case to avoid confusion:
3481 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3482 This means it is likely to be an o32 file, but not for
3483 sure. */
3484 break;
3485 default: strcat (buf, _(", unknown ABI")); break;
3486 }
3487
3488 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3489 strcat (buf, ", mdmx");
3490
3491 if (e_flags & EF_MIPS_ARCH_ASE_M16)
3492 strcat (buf, ", mips16");
3493
3494 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3495 strcat (buf, ", micromips");
3496
3497 switch ((e_flags & EF_MIPS_ARCH))
3498 {
3499 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3500 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3501 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3502 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3503 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3504 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3505 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3506 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3507 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3508 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3509 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3510 default: strcat (buf, _(", unknown ISA")); break;
3511 }
3512 break;
3513
3514 case EM_NDS32:
3515 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3516 break;
3517
3518 case EM_NFP:
3519 switch (EF_NFP_MACH (e_flags))
3520 {
3521 case E_NFP_MACH_3200:
3522 strcat (buf, ", NFP-32xx");
3523 break;
3524 case E_NFP_MACH_6000:
3525 strcat (buf, ", NFP-6xxx");
3526 break;
3527 }
3528 break;
3529
3530 case EM_RISCV:
3531 if (e_flags & EF_RISCV_RVC)
3532 strcat (buf, ", RVC");
3533
3534 if (e_flags & EF_RISCV_RVE)
3535 strcat (buf, ", RVE");
3536
3537 switch (e_flags & EF_RISCV_FLOAT_ABI)
3538 {
3539 case EF_RISCV_FLOAT_ABI_SOFT:
3540 strcat (buf, ", soft-float ABI");
3541 break;
3542
3543 case EF_RISCV_FLOAT_ABI_SINGLE:
3544 strcat (buf, ", single-float ABI");
3545 break;
3546
3547 case EF_RISCV_FLOAT_ABI_DOUBLE:
3548 strcat (buf, ", double-float ABI");
3549 break;
3550
3551 case EF_RISCV_FLOAT_ABI_QUAD:
3552 strcat (buf, ", quad-float ABI");
3553 break;
3554 }
3555 break;
3556
3557 case EM_SH:
3558 switch ((e_flags & EF_SH_MACH_MASK))
3559 {
3560 case EF_SH1: strcat (buf, ", sh1"); break;
3561 case EF_SH2: strcat (buf, ", sh2"); break;
3562 case EF_SH3: strcat (buf, ", sh3"); break;
3563 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3564 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3565 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3566 case EF_SH3E: strcat (buf, ", sh3e"); break;
3567 case EF_SH4: strcat (buf, ", sh4"); break;
3568 case EF_SH5: strcat (buf, ", sh5"); break;
3569 case EF_SH2E: strcat (buf, ", sh2e"); break;
3570 case EF_SH4A: strcat (buf, ", sh4a"); break;
3571 case EF_SH2A: strcat (buf, ", sh2a"); break;
3572 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3573 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3574 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3575 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3576 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3577 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3578 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3579 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3580 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3581 default: strcat (buf, _(", unknown ISA")); break;
3582 }
3583
3584 if (e_flags & EF_SH_PIC)
3585 strcat (buf, ", pic");
3586
3587 if (e_flags & EF_SH_FDPIC)
3588 strcat (buf, ", fdpic");
3589 break;
3590
3591 case EM_OR1K:
3592 if (e_flags & EF_OR1K_NODELAY)
3593 strcat (buf, ", no delay");
3594 break;
3595
3596 case EM_SPARCV9:
3597 if (e_flags & EF_SPARC_32PLUS)
3598 strcat (buf, ", v8+");
3599
3600 if (e_flags & EF_SPARC_SUN_US1)
3601 strcat (buf, ", ultrasparcI");
3602
3603 if (e_flags & EF_SPARC_SUN_US3)
3604 strcat (buf, ", ultrasparcIII");
3605
3606 if (e_flags & EF_SPARC_HAL_R1)
3607 strcat (buf, ", halr1");
3608
3609 if (e_flags & EF_SPARC_LEDATA)
3610 strcat (buf, ", ledata");
3611
3612 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3613 strcat (buf, ", tso");
3614
3615 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3616 strcat (buf, ", pso");
3617
3618 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3619 strcat (buf, ", rmo");
3620 break;
3621
3622 case EM_PARISC:
3623 switch (e_flags & EF_PARISC_ARCH)
3624 {
3625 case EFA_PARISC_1_0:
3626 strcpy (buf, ", PA-RISC 1.0");
3627 break;
3628 case EFA_PARISC_1_1:
3629 strcpy (buf, ", PA-RISC 1.1");
3630 break;
3631 case EFA_PARISC_2_0:
3632 strcpy (buf, ", PA-RISC 2.0");
3633 break;
3634 default:
3635 break;
3636 }
3637 if (e_flags & EF_PARISC_TRAPNIL)
3638 strcat (buf, ", trapnil");
3639 if (e_flags & EF_PARISC_EXT)
3640 strcat (buf, ", ext");
3641 if (e_flags & EF_PARISC_LSB)
3642 strcat (buf, ", lsb");
3643 if (e_flags & EF_PARISC_WIDE)
3644 strcat (buf, ", wide");
3645 if (e_flags & EF_PARISC_NO_KABP)
3646 strcat (buf, ", no kabp");
3647 if (e_flags & EF_PARISC_LAZYSWAP)
3648 strcat (buf, ", lazyswap");
3649 break;
3650
3651 case EM_PJ:
3652 case EM_PJ_OLD:
3653 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3654 strcat (buf, ", new calling convention");
3655
3656 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3657 strcat (buf, ", gnu calling convention");
3658 break;
3659
3660 case EM_IA_64:
3661 if ((e_flags & EF_IA_64_ABI64))
3662 strcat (buf, ", 64-bit");
3663 else
3664 strcat (buf, ", 32-bit");
3665 if ((e_flags & EF_IA_64_REDUCEDFP))
3666 strcat (buf, ", reduced fp model");
3667 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3668 strcat (buf, ", no function descriptors, constant gp");
3669 else if ((e_flags & EF_IA_64_CONS_GP))
3670 strcat (buf, ", constant gp");
3671 if ((e_flags & EF_IA_64_ABSOLUTE))
3672 strcat (buf, ", absolute");
3673 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3674 {
3675 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3676 strcat (buf, ", vms_linkages");
3677 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3678 {
3679 case EF_IA_64_VMS_COMCOD_SUCCESS:
3680 break;
3681 case EF_IA_64_VMS_COMCOD_WARNING:
3682 strcat (buf, ", warning");
3683 break;
3684 case EF_IA_64_VMS_COMCOD_ERROR:
3685 strcat (buf, ", error");
3686 break;
3687 case EF_IA_64_VMS_COMCOD_ABORT:
3688 strcat (buf, ", abort");
3689 break;
3690 default:
3691 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3692 e_flags & EF_IA_64_VMS_COMCOD);
3693 strcat (buf, ", <unknown>");
3694 }
3695 }
3696 break;
3697
3698 case EM_VAX:
3699 if ((e_flags & EF_VAX_NONPIC))
3700 strcat (buf, ", non-PIC");
3701 if ((e_flags & EF_VAX_DFLOAT))
3702 strcat (buf, ", D-Float");
3703 if ((e_flags & EF_VAX_GFLOAT))
3704 strcat (buf, ", G-Float");
3705 break;
3706
3707 case EM_VISIUM:
3708 if (e_flags & EF_VISIUM_ARCH_MCM)
3709 strcat (buf, ", mcm");
3710 else if (e_flags & EF_VISIUM_ARCH_MCM24)
3711 strcat (buf, ", mcm24");
3712 if (e_flags & EF_VISIUM_ARCH_GR6)
3713 strcat (buf, ", gr6");
3714 break;
3715
3716 case EM_RL78:
3717 switch (e_flags & E_FLAG_RL78_CPU_MASK)
3718 {
3719 case E_FLAG_RL78_ANY_CPU: break;
3720 case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3721 case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3722 case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3723 }
3724 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3725 strcat (buf, ", 64-bit doubles");
3726 break;
3727
3728 case EM_RX:
3729 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3730 strcat (buf, ", 64-bit doubles");
3731 if (e_flags & E_FLAG_RX_DSP)
3732 strcat (buf, ", dsp");
3733 if (e_flags & E_FLAG_RX_PID)
3734 strcat (buf, ", pid");
3735 if (e_flags & E_FLAG_RX_ABI)
3736 strcat (buf, ", RX ABI");
3737 if (e_flags & E_FLAG_RX_SINSNS_SET)
3738 strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3739 ? ", uses String instructions" : ", bans String instructions");
3740 if (e_flags & E_FLAG_RX_V2)
3741 strcat (buf, ", V2");
3742 if (e_flags & E_FLAG_RX_V3)
3743 strcat (buf, ", V3");
3744 break;
3745
3746 case EM_S390:
3747 if (e_flags & EF_S390_HIGH_GPRS)
3748 strcat (buf, ", highgprs");
3749 break;
3750
3751 case EM_TI_C6000:
3752 if ((e_flags & EF_C6000_REL))
3753 strcat (buf, ", relocatable module");
3754 break;
3755
3756 case EM_MSP430:
3757 strcat (buf, _(": architecture variant: "));
3758 switch (e_flags & EF_MSP430_MACH)
3759 {
3760 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3761 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3762 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3763 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3764 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3765 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3766 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3767 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3768 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3769 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3770 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3771 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3772 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3773 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3774 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3775 default:
3776 strcat (buf, _(": unknown")); break;
3777 }
3778
3779 if (e_flags & ~ EF_MSP430_MACH)
3780 strcat (buf, _(": unknown extra flag bits also present"));
3781 }
3782 }
3783
3784 return buf;
3785 }
3786
3787 static const char *
3788 get_osabi_name (Filedata * filedata, unsigned int osabi)
3789 {
3790 static char buff[32];
3791
3792 switch (osabi)
3793 {
3794 case ELFOSABI_NONE: return "UNIX - System V";
3795 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3796 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
3797 case ELFOSABI_GNU: return "UNIX - GNU";
3798 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3799 case ELFOSABI_AIX: return "UNIX - AIX";
3800 case ELFOSABI_IRIX: return "UNIX - IRIX";
3801 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3802 case ELFOSABI_TRU64: return "UNIX - TRU64";
3803 case ELFOSABI_MODESTO: return "Novell - Modesto";
3804 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3805 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3806 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3807 case ELFOSABI_AROS: return "AROS";
3808 case ELFOSABI_FENIXOS: return "FenixOS";
3809 case ELFOSABI_CLOUDABI: return "Nuxi CloudABI";
3810 case ELFOSABI_OPENVOS: return "Stratus Technologies OpenVOS";
3811 default:
3812 if (osabi >= 64)
3813 switch (filedata->file_header.e_machine)
3814 {
3815 case EM_AMDGPU:
3816 switch (osabi)
3817 {
3818 case ELFOSABI_AMDGPU_HSA: return "AMD HSA Runtime";
3819 default:
3820 break;
3821 }
3822 break;
3823
3824 case EM_ARM:
3825 switch (osabi)
3826 {
3827 case ELFOSABI_ARM: return "ARM";
3828 case ELFOSABI_ARM_FDPIC: return "ARM FDPIC";
3829 default:
3830 break;
3831 }
3832 break;
3833
3834 case EM_MSP430:
3835 case EM_MSP430_OLD:
3836 case EM_VISIUM:
3837 switch (osabi)
3838 {
3839 case ELFOSABI_STANDALONE: return _("Standalone App");
3840 default:
3841 break;
3842 }
3843 break;
3844
3845 case EM_TI_C6000:
3846 switch (osabi)
3847 {
3848 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3849 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3850 default:
3851 break;
3852 }
3853 break;
3854
3855 default:
3856 break;
3857 }
3858 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3859 return buff;
3860 }
3861 }
3862
3863 static const char *
3864 get_aarch64_segment_type (unsigned long type)
3865 {
3866 switch (type)
3867 {
3868 case PT_AARCH64_ARCHEXT: return "AARCH64_ARCHEXT";
3869 default: return NULL;
3870 }
3871 }
3872
3873 static const char *
3874 get_arm_segment_type (unsigned long type)
3875 {
3876 switch (type)
3877 {
3878 case PT_ARM_EXIDX: return "EXIDX";
3879 default: return NULL;
3880 }
3881 }
3882
3883 static const char *
3884 get_s390_segment_type (unsigned long type)
3885 {
3886 switch (type)
3887 {
3888 case PT_S390_PGSTE: return "S390_PGSTE";
3889 default: return NULL;
3890 }
3891 }
3892
3893 static const char *
3894 get_mips_segment_type (unsigned long type)
3895 {
3896 switch (type)
3897 {
3898 case PT_MIPS_REGINFO: return "REGINFO";
3899 case PT_MIPS_RTPROC: return "RTPROC";
3900 case PT_MIPS_OPTIONS: return "OPTIONS";
3901 case PT_MIPS_ABIFLAGS: return "ABIFLAGS";
3902 default: return NULL;
3903 }
3904 }
3905
3906 static const char *
3907 get_parisc_segment_type (unsigned long type)
3908 {
3909 switch (type)
3910 {
3911 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3912 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
3913 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
3914 default: return NULL;
3915 }
3916 }
3917
3918 static const char *
3919 get_ia64_segment_type (unsigned long type)
3920 {
3921 switch (type)
3922 {
3923 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3924 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
3925 default: return NULL;
3926 }
3927 }
3928
3929 static const char *
3930 get_tic6x_segment_type (unsigned long type)
3931 {
3932 switch (type)
3933 {
3934 case PT_C6000_PHATTR: return "C6000_PHATTR";
3935 default: return NULL;
3936 }
3937 }
3938
3939 static const char *
3940 get_hpux_segment_type (unsigned long type, unsigned e_machine)
3941 {
3942 if (e_machine == EM_PARISC)
3943 switch (type)
3944 {
3945 case PT_HP_TLS: return "HP_TLS";
3946 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3947 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3948 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3949 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3950 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3951 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3952 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3953 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3954 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3955 case PT_HP_PARALLEL: return "HP_PARALLEL";
3956 case PT_HP_FASTBIND: return "HP_FASTBIND";
3957 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3958 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3959 case PT_HP_STACK: return "HP_STACK";
3960 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
3961 default: return NULL;
3962 }
3963
3964 if (e_machine == EM_IA_64)
3965 switch (type)
3966 {
3967 case PT_HP_TLS: return "HP_TLS";
3968 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3969 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3970 case PT_IA_64_HP_STACK: return "HP_STACK";
3971 default: return NULL;
3972 }
3973
3974 return NULL;
3975 }
3976
3977 static const char *
3978 get_solaris_segment_type (unsigned long type)
3979 {
3980 switch (type)
3981 {
3982 case 0x6464e550: return "PT_SUNW_UNWIND";
3983 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3984 case 0x6ffffff7: return "PT_LOSUNW";
3985 case 0x6ffffffa: return "PT_SUNWBSS";
3986 case 0x6ffffffb: return "PT_SUNWSTACK";
3987 case 0x6ffffffc: return "PT_SUNWDTRACE";
3988 case 0x6ffffffd: return "PT_SUNWCAP";
3989 case 0x6fffffff: return "PT_HISUNW";
3990 default: return NULL;
3991 }
3992 }
3993
3994 static const char *
3995 get_segment_type (Filedata * filedata, unsigned long p_type)
3996 {
3997 static char buff[32];
3998
3999 switch (p_type)
4000 {
4001 case PT_NULL: return "NULL";
4002 case PT_LOAD: return "LOAD";
4003 case PT_DYNAMIC: return "DYNAMIC";
4004 case PT_INTERP: return "INTERP";
4005 case PT_NOTE: return "NOTE";
4006 case PT_SHLIB: return "SHLIB";
4007 case PT_PHDR: return "PHDR";
4008 case PT_TLS: return "TLS";
4009 case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
4010 case PT_GNU_STACK: return "GNU_STACK";
4011 case PT_GNU_RELRO: return "GNU_RELRO";
4012 case PT_GNU_PROPERTY: return "GNU_PROPERTY";
4013
4014 default:
4015 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
4016 {
4017 const char * result;
4018
4019 switch (filedata->file_header.e_machine)
4020 {
4021 case EM_AARCH64:
4022 result = get_aarch64_segment_type (p_type);
4023 break;
4024 case EM_ARM:
4025 result = get_arm_segment_type (p_type);
4026 break;
4027 case EM_MIPS:
4028 case EM_MIPS_RS3_LE:
4029 result = get_mips_segment_type (p_type);
4030 break;
4031 case EM_PARISC:
4032 result = get_parisc_segment_type (p_type);
4033 break;
4034 case EM_IA_64:
4035 result = get_ia64_segment_type (p_type);
4036 break;
4037 case EM_TI_C6000:
4038 result = get_tic6x_segment_type (p_type);
4039 break;
4040 case EM_S390:
4041 case EM_S390_OLD:
4042 result = get_s390_segment_type (p_type);
4043 break;
4044 default:
4045 result = NULL;
4046 break;
4047 }
4048
4049 if (result != NULL)
4050 return result;
4051
4052 sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
4053 }
4054 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
4055 {
4056 const char * result = NULL;
4057
4058 switch (filedata->file_header.e_ident[EI_OSABI])
4059 {
4060 case ELFOSABI_GNU:
4061 case ELFOSABI_FREEBSD:
4062 if (p_type >= PT_GNU_MBIND_LO && p_type <= PT_GNU_MBIND_HI)
4063 {
4064 sprintf (buff, "GNU_MBIND+%#lx", p_type - PT_GNU_MBIND_LO);
4065 result = buff;
4066 }
4067 break;
4068 case ELFOSABI_HPUX:
4069 result = get_hpux_segment_type (p_type,
4070 filedata->file_header.e_machine);
4071 break;
4072 case ELFOSABI_SOLARIS:
4073 result = get_solaris_segment_type (p_type);
4074 break;
4075 default:
4076 break;
4077 }
4078 if (result != NULL)
4079 return result;
4080
4081 sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
4082 }
4083 else
4084 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
4085
4086 return buff;
4087 }
4088 }
4089
4090 static const char *
4091 get_arc_section_type_name (unsigned int sh_type)
4092 {
4093 switch (sh_type)
4094 {
4095 case SHT_ARC_ATTRIBUTES: return "ARC_ATTRIBUTES";
4096 default:
4097 break;
4098 }
4099 return NULL;
4100 }
4101
4102 static const char *
4103 get_mips_section_type_name (unsigned int sh_type)
4104 {
4105 switch (sh_type)
4106 {
4107 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
4108 case SHT_MIPS_MSYM: return "MIPS_MSYM";
4109 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
4110 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
4111 case SHT_MIPS_UCODE: return "MIPS_UCODE";
4112 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
4113 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
4114 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
4115 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
4116 case SHT_MIPS_RELD: return "MIPS_RELD";
4117 case SHT_MIPS_IFACE: return "MIPS_IFACE";
4118 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
4119 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
4120 case SHT_MIPS_SHDR: return "MIPS_SHDR";
4121 case SHT_MIPS_FDESC: return "MIPS_FDESC";
4122 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
4123 case SHT_MIPS_DENSE: return "MIPS_DENSE";
4124 case SHT_MIPS_PDESC: return "MIPS_PDESC";
4125 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
4126 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
4127 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
4128 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
4129 case SHT_MIPS_LINE: return "MIPS_LINE";
4130 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
4131 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
4132 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
4133 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
4134 case SHT_MIPS_DWARF: return "MIPS_DWARF";
4135 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
4136 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
4137 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
4138 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
4139 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
4140 case SHT_MIPS_XLATE: return "MIPS_XLATE";
4141 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
4142 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
4143 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
4144 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
4145 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
4146 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
4147 case SHT_MIPS_XHASH: return "MIPS_XHASH";
4148 default:
4149 break;
4150 }
4151 return NULL;
4152 }
4153
4154 static const char *
4155 get_parisc_section_type_name (unsigned int sh_type)
4156 {
4157 switch (sh_type)
4158 {
4159 case SHT_PARISC_EXT: return "PARISC_EXT";
4160 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
4161 case SHT_PARISC_DOC: return "PARISC_DOC";
4162 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
4163 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
4164 case SHT_PARISC_STUBS: return "PARISC_STUBS";
4165 case SHT_PARISC_DLKM: return "PARISC_DLKM";
4166 default: return NULL;
4167 }
4168 }
4169
4170 static const char *
4171 get_ia64_section_type_name (Filedata * filedata, unsigned int sh_type)
4172 {
4173 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4174 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
4175 return get_osabi_name (filedata, (sh_type & 0x00FF0000) >> 16);
4176
4177 switch (sh_type)
4178 {
4179 case SHT_IA_64_EXT: return "IA_64_EXT";
4180 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
4181 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
4182 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
4183 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
4184 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
4185 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
4186 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
4187 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
4188 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4189 default:
4190 break;
4191 }
4192 return NULL;
4193 }
4194
4195 static const char *
4196 get_x86_64_section_type_name (unsigned int sh_type)
4197 {
4198 switch (sh_type)
4199 {
4200 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
4201 default: return NULL;
4202 }
4203 }
4204
4205 static const char *
4206 get_aarch64_section_type_name (unsigned int sh_type)
4207 {
4208 switch (sh_type)
4209 {
4210 case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
4211 default: return NULL;
4212 }
4213 }
4214
4215 static const char *
4216 get_arm_section_type_name (unsigned int sh_type)
4217 {
4218 switch (sh_type)
4219 {
4220 case SHT_ARM_EXIDX: return "ARM_EXIDX";
4221 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
4222 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
4223 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
4224 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
4225 default: return NULL;
4226 }
4227 }
4228
4229 static const char *
4230 get_tic6x_section_type_name (unsigned int sh_type)
4231 {
4232 switch (sh_type)
4233 {
4234 case SHT_C6000_UNWIND: return "C6000_UNWIND";
4235 case SHT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
4236 case SHT_C6000_ATTRIBUTES: return "C6000_ATTRIBUTES";
4237 case SHT_TI_ICODE: return "TI_ICODE";
4238 case SHT_TI_XREF: return "TI_XREF";
4239 case SHT_TI_HANDLER: return "TI_HANDLER";
4240 case SHT_TI_INITINFO: return "TI_INITINFO";
4241 case SHT_TI_PHATTRS: return "TI_PHATTRS";
4242 default: return NULL;
4243 }
4244 }
4245
4246 static const char *
4247 get_msp430x_section_type_name (unsigned int sh_type)
4248 {
4249 switch (sh_type)
4250 {
4251 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
4252 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
4253 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
4254 default: return NULL;
4255 }
4256 }
4257
4258 static const char *
4259 get_nfp_section_type_name (unsigned int sh_type)
4260 {
4261 switch (sh_type)
4262 {
4263 case SHT_NFP_MECONFIG: return "NFP_MECONFIG";
4264 case SHT_NFP_INITREG: return "NFP_INITREG";
4265 case SHT_NFP_UDEBUG: return "NFP_UDEBUG";
4266 default: return NULL;
4267 }
4268 }
4269
4270 static const char *
4271 get_v850_section_type_name (unsigned int sh_type)
4272 {
4273 switch (sh_type)
4274 {
4275 case SHT_V850_SCOMMON: return "V850 Small Common";
4276 case SHT_V850_TCOMMON: return "V850 Tiny Common";
4277 case SHT_V850_ZCOMMON: return "V850 Zero Common";
4278 case SHT_RENESAS_IOP: return "RENESAS IOP";
4279 case SHT_RENESAS_INFO: return "RENESAS INFO";
4280 default: return NULL;
4281 }
4282 }
4283
4284 static const char *
4285 get_riscv_section_type_name (unsigned int sh_type)
4286 {
4287 switch (sh_type)
4288 {
4289 case SHT_RISCV_ATTRIBUTES: return "RISCV_ATTRIBUTES";
4290 default: return NULL;
4291 }
4292 }
4293
4294 static const char *
4295 get_section_type_name (Filedata * filedata, unsigned int sh_type)
4296 {
4297 static char buff[32];
4298 const char * result;
4299
4300 switch (sh_type)
4301 {
4302 case SHT_NULL: return "NULL";
4303 case SHT_PROGBITS: return "PROGBITS";
4304 case SHT_SYMTAB: return "SYMTAB";
4305 case SHT_STRTAB: return "STRTAB";
4306 case SHT_RELA: return "RELA";
4307 case SHT_HASH: return "HASH";
4308 case SHT_DYNAMIC: return "DYNAMIC";
4309 case SHT_NOTE: return "NOTE";
4310 case SHT_NOBITS: return "NOBITS";
4311 case SHT_REL: return "REL";
4312 case SHT_SHLIB: return "SHLIB";
4313 case SHT_DYNSYM: return "DYNSYM";
4314 case SHT_INIT_ARRAY: return "INIT_ARRAY";
4315 case SHT_FINI_ARRAY: return "FINI_ARRAY";
4316 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
4317 case SHT_GNU_HASH: return "GNU_HASH";
4318 case SHT_GROUP: return "GROUP";
4319 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICES";
4320 case SHT_GNU_verdef: return "VERDEF";
4321 case SHT_GNU_verneed: return "VERNEED";
4322 case SHT_GNU_versym: return "VERSYM";
4323 case 0x6ffffff0: return "VERSYM";
4324 case 0x6ffffffc: return "VERDEF";
4325 case 0x7ffffffd: return "AUXILIARY";
4326 case 0x7fffffff: return "FILTER";
4327 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
4328
4329 default:
4330 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4331 {
4332 switch (filedata->file_header.e_machine)
4333 {
4334 case EM_ARC:
4335 case EM_ARC_COMPACT:
4336 case EM_ARC_COMPACT2:
4337 result = get_arc_section_type_name (sh_type);
4338 break;
4339 case EM_MIPS:
4340 case EM_MIPS_RS3_LE:
4341 result = get_mips_section_type_name (sh_type);
4342 break;
4343 case EM_PARISC:
4344 result = get_parisc_section_type_name (sh_type);
4345 break;
4346 case EM_IA_64:
4347 result = get_ia64_section_type_name (filedata, sh_type);
4348 break;
4349 case EM_X86_64:
4350 case EM_L1OM:
4351 case EM_K1OM:
4352 result = get_x86_64_section_type_name (sh_type);
4353 break;
4354 case EM_AARCH64:
4355 result = get_aarch64_section_type_name (sh_type);
4356 break;
4357 case EM_ARM:
4358 result = get_arm_section_type_name (sh_type);
4359 break;
4360 case EM_TI_C6000:
4361 result = get_tic6x_section_type_name (sh_type);
4362 break;
4363 case EM_MSP430:
4364 result = get_msp430x_section_type_name (sh_type);
4365 break;
4366 case EM_NFP:
4367 result = get_nfp_section_type_name (sh_type);
4368 break;
4369 case EM_V800:
4370 case EM_V850:
4371 case EM_CYGNUS_V850:
4372 result = get_v850_section_type_name (sh_type);
4373 break;
4374 case EM_RISCV:
4375 result = get_riscv_section_type_name (sh_type);
4376 break;
4377 default:
4378 result = NULL;
4379 break;
4380 }
4381
4382 if (result != NULL)
4383 return result;
4384
4385 sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
4386 }
4387 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
4388 {
4389 switch (filedata->file_header.e_machine)
4390 {
4391 case EM_IA_64:
4392 result = get_ia64_section_type_name (filedata, sh_type);
4393 break;
4394 default:
4395 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4396 result = get_solaris_section_type (sh_type);
4397 else
4398 {
4399 switch (sh_type)
4400 {
4401 case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
4402 case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
4403 case SHT_GNU_HASH: result = "GNU_HASH"; break;
4404 case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
4405 default:
4406 result = NULL;
4407 break;
4408 }
4409 }
4410 break;
4411 }
4412
4413 if (result != NULL)
4414 return result;
4415
4416 sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
4417 }
4418 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
4419 {
4420 switch (filedata->file_header.e_machine)
4421 {
4422 case EM_V800:
4423 case EM_V850:
4424 case EM_CYGNUS_V850:
4425 result = get_v850_section_type_name (sh_type);
4426 break;
4427 default:
4428 result = NULL;
4429 break;
4430 }
4431
4432 if (result != NULL)
4433 return result;
4434
4435 sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4436 }
4437 else
4438 /* This message is probably going to be displayed in a 15
4439 character wide field, so put the hex value first. */
4440 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
4441
4442 return buff;
4443 }
4444 }
4445
4446 #define OPTION_DEBUG_DUMP 512
4447 #define OPTION_DYN_SYMS 513
4448 #define OPTION_DWARF_DEPTH 514
4449 #define OPTION_DWARF_START 515
4450 #define OPTION_DWARF_CHECK 516
4451 #define OPTION_CTF_DUMP 517
4452 #define OPTION_CTF_PARENT 518
4453 #define OPTION_CTF_SYMBOLS 519
4454 #define OPTION_CTF_STRINGS 520
4455
4456 static struct option options[] =
4457 {
4458 {"all", no_argument, 0, 'a'},
4459 {"file-header", no_argument, 0, 'h'},
4460 {"program-headers", no_argument, 0, 'l'},
4461 {"headers", no_argument, 0, 'e'},
4462 {"histogram", no_argument, 0, 'I'},
4463 {"segments", no_argument, 0, 'l'},
4464 {"sections", no_argument, 0, 'S'},
4465 {"section-headers", no_argument, 0, 'S'},
4466 {"section-groups", no_argument, 0, 'g'},
4467 {"section-details", no_argument, 0, 't'},
4468 {"full-section-name",no_argument, 0, 'N'},
4469 {"symbols", no_argument, 0, 's'},
4470 {"syms", no_argument, 0, 's'},
4471 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
4472 {"relocs", no_argument, 0, 'r'},
4473 {"notes", no_argument, 0, 'n'},
4474 {"dynamic", no_argument, 0, 'd'},
4475 {"arch-specific", no_argument, 0, 'A'},
4476 {"version-info", no_argument, 0, 'V'},
4477 {"use-dynamic", no_argument, 0, 'D'},
4478 {"unwind", no_argument, 0, 'u'},
4479 {"archive-index", no_argument, 0, 'c'},
4480 {"hex-dump", required_argument, 0, 'x'},
4481 {"relocated-dump", required_argument, 0, 'R'},
4482 {"string-dump", required_argument, 0, 'p'},
4483 {"decompress", no_argument, 0, 'z'},
4484 #ifdef SUPPORT_DISASSEMBLY
4485 {"instruction-dump", required_argument, 0, 'i'},
4486 #endif
4487 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
4488
4489 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
4490 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4491 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
4492
4493 {"ctf", required_argument, 0, OPTION_CTF_DUMP},
4494
4495 {"ctf-symbols", required_argument, 0, OPTION_CTF_SYMBOLS},
4496 {"ctf-strings", required_argument, 0, OPTION_CTF_STRINGS},
4497 {"ctf-parent", required_argument, 0, OPTION_CTF_PARENT},
4498
4499 {"version", no_argument, 0, 'v'},
4500 {"wide", no_argument, 0, 'W'},
4501 {"help", no_argument, 0, 'H'},
4502 {0, no_argument, 0, 0}
4503 };
4504
4505 static void
4506 usage (FILE * stream)
4507 {
4508 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4509 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4510 fprintf (stream, _(" Options are:\n\
4511 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4512 -h --file-header Display the ELF file header\n\
4513 -l --program-headers Display the program headers\n\
4514 --segments An alias for --program-headers\n\
4515 -S --section-headers Display the sections' header\n\
4516 --sections An alias for --section-headers\n\
4517 -g --section-groups Display the section groups\n\
4518 -t --section-details Display the section details\n\
4519 -e --headers Equivalent to: -h -l -S\n\
4520 -s --syms Display the symbol table\n\
4521 --symbols An alias for --syms\n\
4522 --dyn-syms Display the dynamic symbol table\n\
4523 -n --notes Display the core notes (if present)\n\
4524 -r --relocs Display the relocations (if present)\n\
4525 -u --unwind Display the unwind info (if present)\n\
4526 -d --dynamic Display the dynamic section (if present)\n\
4527 -V --version-info Display the version sections (if present)\n\
4528 -A --arch-specific Display architecture specific information (if any)\n\
4529 -c --archive-index Display the symbol/file index in an archive\n\
4530 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4531 -x --hex-dump=<number|name>\n\
4532 Dump the contents of section <number|name> as bytes\n\
4533 -p --string-dump=<number|name>\n\
4534 Dump the contents of section <number|name> as strings\n\
4535 -R --relocated-dump=<number|name>\n\
4536 Dump the contents of section <number|name> as relocated bytes\n\
4537 -z --decompress Decompress section before dumping it\n\
4538 -w[lLiaprmfFsoRtUuTgAckK] or\n\
4539 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4540 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4541 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4542 =addr,=cu_index,=links,=follow-links]\n\
4543 Display the contents of DWARF debug sections\n"));
4544 fprintf (stream, _("\
4545 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4546 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4547 or deeper\n"));
4548 fprintf (stream, _("\
4549 --ctf=<number|name> Display CTF info from section <number|name>\n\
4550 --ctf-parent=<number|name>\n\
4551 Use section <number|name> as the CTF parent\n\n\
4552 --ctf-symbols=<number|name>\n\
4553 Use section <number|name> as the CTF external symtab\n\n\
4554 --ctf-strings=<number|name>\n\
4555 Use section <number|name> as the CTF external strtab\n\n"));
4556
4557 #ifdef SUPPORT_DISASSEMBLY
4558 fprintf (stream, _("\
4559 -i --instruction-dump=<number|name>\n\
4560 Disassemble the contents of section <number|name>\n"));
4561 #endif
4562 fprintf (stream, _("\
4563 -I --histogram Display histogram of bucket list lengths\n\
4564 -W --wide Allow output width to exceed 80 characters\n\
4565 @<file> Read options from <file>\n\
4566 -H --help Display this information\n\
4567 -v --version Display the version number of readelf\n"));
4568
4569 if (REPORT_BUGS_TO[0] && stream == stdout)
4570 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4571
4572 exit (stream == stdout ? 0 : 1);
4573 }
4574
4575 /* Record the fact that the user wants the contents of section number
4576 SECTION to be displayed using the method(s) encoded as flags bits
4577 in TYPE. Note, TYPE can be zero if we are creating the array for
4578 the first time. */
4579
4580 static void
4581 request_dump_bynumber (Filedata * filedata, unsigned int section, dump_type type)
4582 {
4583 if (section >= filedata->num_dump_sects)
4584 {
4585 dump_type * new_dump_sects;
4586
4587 new_dump_sects = (dump_type *) calloc (section + 1,
4588 sizeof (* new_dump_sects));
4589
4590 if (new_dump_sects == NULL)
4591 error (_("Out of memory allocating dump request table.\n"));
4592 else
4593 {
4594 if (filedata->dump_sects)
4595 {
4596 /* Copy current flag settings. */
4597 memcpy (new_dump_sects, filedata->dump_sects,
4598 filedata->num_dump_sects * sizeof (* new_dump_sects));
4599
4600 free (filedata->dump_sects);
4601 }
4602
4603 filedata->dump_sects = new_dump_sects;
4604 filedata->num_dump_sects = section + 1;
4605 }
4606 }
4607
4608 if (filedata->dump_sects)
4609 filedata->dump_sects[section] |= type;
4610 }
4611
4612 /* Request a dump by section name. */
4613
4614 static void
4615 request_dump_byname (const char * section, dump_type type)
4616 {
4617 struct dump_list_entry * new_request;
4618
4619 new_request = (struct dump_list_entry *)
4620 malloc (sizeof (struct dump_list_entry));
4621 if (!new_request)
4622 error (_("Out of memory allocating dump request table.\n"));
4623
4624 new_request->name = strdup (section);
4625 if (!new_request->name)
4626 error (_("Out of memory allocating dump request table.\n"));
4627
4628 new_request->type = type;
4629
4630 new_request->next = dump_sects_byname;
4631 dump_sects_byname = new_request;
4632 }
4633
4634 static inline void
4635 request_dump (Filedata * filedata, dump_type type)
4636 {
4637 int section;
4638 char * cp;
4639
4640 do_dump++;
4641 section = strtoul (optarg, & cp, 0);
4642
4643 if (! *cp && section >= 0)
4644 request_dump_bynumber (filedata, section, type);
4645 else
4646 request_dump_byname (optarg, type);
4647 }
4648
4649 static void
4650 parse_args (Filedata * filedata, int argc, char ** argv)
4651 {
4652 int c;
4653
4654 if (argc < 2)
4655 usage (stderr);
4656
4657 while ((c = getopt_long
4658 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4659 {
4660 switch (c)
4661 {
4662 case 0:
4663 /* Long options. */
4664 break;
4665 case 'H':
4666 usage (stdout);
4667 break;
4668
4669 case 'a':
4670 do_syms = TRUE;
4671 do_reloc = TRUE;
4672 do_unwind = TRUE;
4673 do_dynamic = TRUE;
4674 do_header = TRUE;
4675 do_sections = TRUE;
4676 do_section_groups = TRUE;
4677 do_segments = TRUE;
4678 do_version = TRUE;
4679 do_histogram = TRUE;
4680 do_arch = TRUE;
4681 do_notes = TRUE;
4682 break;
4683 case 'g':
4684 do_section_groups = TRUE;
4685 break;
4686 case 't':
4687 case 'N':
4688 do_sections = TRUE;
4689 do_section_details = TRUE;
4690 break;
4691 case 'e':
4692 do_header = TRUE;
4693 do_sections = TRUE;
4694 do_segments = TRUE;
4695 break;
4696 case 'A':
4697 do_arch = TRUE;
4698 break;
4699 case 'D':
4700 do_using_dynamic = TRUE;
4701 break;
4702 case 'r':
4703 do_reloc = TRUE;
4704 break;
4705 case 'u':
4706 do_unwind = TRUE;
4707 break;
4708 case 'h':
4709 do_header = TRUE;
4710 break;
4711 case 'l':
4712 do_segments = TRUE;
4713 break;
4714 case 's':
4715 do_syms = TRUE;
4716 break;
4717 case 'S':
4718 do_sections = TRUE;
4719 break;
4720 case 'd':
4721 do_dynamic = TRUE;
4722 break;
4723 case 'I':
4724 do_histogram = TRUE;
4725 break;
4726 case 'n':
4727 do_notes = TRUE;
4728 break;
4729 case 'c':
4730 do_archive_index = TRUE;
4731 break;
4732 case 'x':
4733 request_dump (filedata, HEX_DUMP);
4734 break;
4735 case 'p':
4736 request_dump (filedata, STRING_DUMP);
4737 break;
4738 case 'R':
4739 request_dump (filedata, RELOC_DUMP);
4740 break;
4741 case 'z':
4742 decompress_dumps = TRUE;
4743 break;
4744 case 'w':
4745 do_dump = TRUE;
4746 if (optarg == 0)
4747 {
4748 do_debugging = TRUE;
4749 dwarf_select_sections_all ();
4750 }
4751 else
4752 {
4753 do_debugging = FALSE;
4754 dwarf_select_sections_by_letters (optarg);
4755 }
4756 break;
4757 case OPTION_DEBUG_DUMP:
4758 do_dump = TRUE;
4759 if (optarg == 0)
4760 do_debugging = TRUE;
4761 else
4762 {
4763 do_debugging = FALSE;
4764 dwarf_select_sections_by_names (optarg);
4765 }
4766 break;
4767 case OPTION_DWARF_DEPTH:
4768 {
4769 char *cp;
4770
4771 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4772 }
4773 break;
4774 case OPTION_DWARF_START:
4775 {
4776 char *cp;
4777
4778 dwarf_start_die = strtoul (optarg, & cp, 0);
4779 }
4780 break;
4781 case OPTION_DWARF_CHECK:
4782 dwarf_check = TRUE;
4783 break;
4784 case OPTION_CTF_DUMP:
4785 do_ctf = TRUE;
4786 request_dump (filedata, CTF_DUMP);
4787 break;
4788 case OPTION_CTF_SYMBOLS:
4789 dump_ctf_symtab_name = strdup (optarg);
4790 break;
4791 case OPTION_CTF_STRINGS:
4792 dump_ctf_strtab_name = strdup (optarg);
4793 break;
4794 case OPTION_CTF_PARENT:
4795 dump_ctf_parent_name = strdup (optarg);
4796 break;
4797 case OPTION_DYN_SYMS:
4798 do_dyn_syms = TRUE;
4799 break;
4800 #ifdef SUPPORT_DISASSEMBLY
4801 case 'i':
4802 request_dump (filedata, DISASS_DUMP);
4803 break;
4804 #endif
4805 case 'v':
4806 print_version (program_name);
4807 break;
4808 case 'V':
4809 do_version = TRUE;
4810 break;
4811 case 'W':
4812 do_wide = TRUE;
4813 break;
4814 default:
4815 /* xgettext:c-format */
4816 error (_("Invalid option '-%c'\n"), c);
4817 /* Fall through. */
4818 case '?':
4819 usage (stderr);
4820 }
4821 }
4822
4823 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4824 && !do_segments && !do_header && !do_dump && !do_version
4825 && !do_histogram && !do_debugging && !do_arch && !do_notes
4826 && !do_section_groups && !do_archive_index
4827 && !do_dyn_syms)
4828 usage (stderr);
4829 }
4830
4831 static const char *
4832 get_elf_class (unsigned int elf_class)
4833 {
4834 static char buff[32];
4835
4836 switch (elf_class)
4837 {
4838 case ELFCLASSNONE: return _("none");
4839 case ELFCLASS32: return "ELF32";
4840 case ELFCLASS64: return "ELF64";
4841 default:
4842 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4843 return buff;
4844 }
4845 }
4846
4847 static const char *
4848 get_data_encoding (unsigned int encoding)
4849 {
4850 static char buff[32];
4851
4852 switch (encoding)
4853 {
4854 case ELFDATANONE: return _("none");
4855 case ELFDATA2LSB: return _("2's complement, little endian");
4856 case ELFDATA2MSB: return _("2's complement, big endian");
4857 default:
4858 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4859 return buff;
4860 }
4861 }
4862
4863 /* Decode the data held in 'filedata->file_header'. */
4864
4865 static bfd_boolean
4866 process_file_header (Filedata * filedata)
4867 {
4868 Elf_Internal_Ehdr * header = & filedata->file_header;
4869
4870 if ( header->e_ident[EI_MAG0] != ELFMAG0
4871 || header->e_ident[EI_MAG1] != ELFMAG1
4872 || header->e_ident[EI_MAG2] != ELFMAG2
4873 || header->e_ident[EI_MAG3] != ELFMAG3)
4874 {
4875 error
4876 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4877 return FALSE;
4878 }
4879
4880 init_dwarf_regnames_by_elf_machine_code (header->e_machine);
4881
4882 if (do_header)
4883 {
4884 unsigned i;
4885
4886 printf (_("ELF Header:\n"));
4887 printf (_(" Magic: "));
4888 for (i = 0; i < EI_NIDENT; i++)
4889 printf ("%2.2x ", header->e_ident[i]);
4890 printf ("\n");
4891 printf (_(" Class: %s\n"),
4892 get_elf_class (header->e_ident[EI_CLASS]));
4893 printf (_(" Data: %s\n"),
4894 get_data_encoding (header->e_ident[EI_DATA]));
4895 printf (_(" Version: %d%s\n"),
4896 header->e_ident[EI_VERSION],
4897 (header->e_ident[EI_VERSION] == EV_CURRENT
4898 ? _(" (current)")
4899 : (header->e_ident[EI_VERSION] != EV_NONE
4900 ? _(" <unknown>")
4901 : "")));
4902 printf (_(" OS/ABI: %s\n"),
4903 get_osabi_name (filedata, header->e_ident[EI_OSABI]));
4904 printf (_(" ABI Version: %d\n"),
4905 header->e_ident[EI_ABIVERSION]);
4906 printf (_(" Type: %s\n"),
4907 get_file_type (header->e_type));
4908 printf (_(" Machine: %s\n"),
4909 get_machine_name (header->e_machine));
4910 printf (_(" Version: 0x%lx\n"),
4911 header->e_version);
4912
4913 printf (_(" Entry point address: "));
4914 print_vma (header->e_entry, PREFIX_HEX);
4915 printf (_("\n Start of program headers: "));
4916 print_vma (header->e_phoff, DEC);
4917 printf (_(" (bytes into file)\n Start of section headers: "));
4918 print_vma (header->e_shoff, DEC);
4919 printf (_(" (bytes into file)\n"));
4920
4921 printf (_(" Flags: 0x%lx%s\n"),
4922 header->e_flags,
4923 get_machine_flags (filedata, header->e_flags, header->e_machine));
4924 printf (_(" Size of this header: %u (bytes)\n"),
4925 header->e_ehsize);
4926 printf (_(" Size of program headers: %u (bytes)\n"),
4927 header->e_phentsize);
4928 printf (_(" Number of program headers: %u"),
4929 header->e_phnum);
4930 if (filedata->section_headers != NULL
4931 && header->e_phnum == PN_XNUM
4932 && filedata->section_headers[0].sh_info != 0)
4933 {
4934 header->e_phnum = filedata->section_headers[0].sh_info;
4935 printf (" (%u)", header->e_phnum);
4936 }
4937 putc ('\n', stdout);
4938 printf (_(" Size of section headers: %u (bytes)\n"),
4939 header->e_shentsize);
4940 printf (_(" Number of section headers: %u"),
4941 header->e_shnum);
4942 if (filedata->section_headers != NULL && header->e_shnum == SHN_UNDEF)
4943 {
4944 header->e_shnum = filedata->section_headers[0].sh_size;
4945 printf (" (%u)", header->e_shnum);
4946 }
4947 putc ('\n', stdout);
4948 printf (_(" Section header string table index: %u"),
4949 header->e_shstrndx);
4950 if (filedata->section_headers != NULL
4951 && header->e_shstrndx == (SHN_XINDEX & 0xffff))
4952 {
4953 header->e_shstrndx = filedata->section_headers[0].sh_link;
4954 printf (" (%u)", header->e_shstrndx);
4955 }
4956 if (header->e_shstrndx != SHN_UNDEF
4957 && header->e_shstrndx >= header->e_shnum)
4958 {
4959 header->e_shstrndx = SHN_UNDEF;
4960 printf (_(" <corrupt: out of range>"));
4961 }
4962 putc ('\n', stdout);
4963 }
4964
4965 if (filedata->section_headers != NULL)
4966 {
4967 if (header->e_phnum == PN_XNUM
4968 && filedata->section_headers[0].sh_info != 0)
4969 header->e_phnum = filedata->section_headers[0].sh_info;
4970 if (header->e_shnum == SHN_UNDEF)
4971 header->e_shnum = filedata->section_headers[0].sh_size;
4972 if (header->e_shstrndx == (SHN_XINDEX & 0xffff))
4973 header->e_shstrndx = filedata->section_headers[0].sh_link;
4974 if (header->e_shstrndx >= header->e_shnum)
4975 header->e_shstrndx = SHN_UNDEF;
4976 free (filedata->section_headers);
4977 filedata->section_headers = NULL;
4978 }
4979
4980 return TRUE;
4981 }
4982
4983 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4984 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
4985
4986 static bfd_boolean
4987 get_32bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4988 {
4989 Elf32_External_Phdr * phdrs;
4990 Elf32_External_Phdr * external;
4991 Elf_Internal_Phdr * internal;
4992 unsigned int i;
4993 unsigned int size = filedata->file_header.e_phentsize;
4994 unsigned int num = filedata->file_header.e_phnum;
4995
4996 /* PR binutils/17531: Cope with unexpected section header sizes. */
4997 if (size == 0 || num == 0)
4998 return FALSE;
4999 if (size < sizeof * phdrs)
5000 {
5001 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5002 return FALSE;
5003 }
5004 if (size > sizeof * phdrs)
5005 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5006
5007 phdrs = (Elf32_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
5008 size, num, _("program headers"));
5009 if (phdrs == NULL)
5010 return FALSE;
5011
5012 for (i = 0, internal = pheaders, external = phdrs;
5013 i < filedata->file_header.e_phnum;
5014 i++, internal++, external++)
5015 {
5016 internal->p_type = BYTE_GET (external->p_type);
5017 internal->p_offset = BYTE_GET (external->p_offset);
5018 internal->p_vaddr = BYTE_GET (external->p_vaddr);
5019 internal->p_paddr = BYTE_GET (external->p_paddr);
5020 internal->p_filesz = BYTE_GET (external->p_filesz);
5021 internal->p_memsz = BYTE_GET (external->p_memsz);
5022 internal->p_flags = BYTE_GET (external->p_flags);
5023 internal->p_align = BYTE_GET (external->p_align);
5024 }
5025
5026 free (phdrs);
5027 return TRUE;
5028 }
5029
5030 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5031 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
5032
5033 static bfd_boolean
5034 get_64bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
5035 {
5036 Elf64_External_Phdr * phdrs;
5037 Elf64_External_Phdr * external;
5038 Elf_Internal_Phdr * internal;
5039 unsigned int i;
5040 unsigned int size = filedata->file_header.e_phentsize;
5041 unsigned int num = filedata->file_header.e_phnum;
5042
5043 /* PR binutils/17531: Cope with unexpected section header sizes. */
5044 if (size == 0 || num == 0)
5045 return FALSE;
5046 if (size < sizeof * phdrs)
5047 {
5048 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5049 return FALSE;
5050 }
5051 if (size > sizeof * phdrs)
5052 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5053
5054 phdrs = (Elf64_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
5055 size, num, _("program headers"));
5056 if (!phdrs)
5057 return FALSE;
5058
5059 for (i = 0, internal = pheaders, external = phdrs;
5060 i < filedata->file_header.e_phnum;
5061 i++, internal++, external++)
5062 {
5063 internal->p_type = BYTE_GET (external->p_type);
5064 internal->p_flags = BYTE_GET (external->p_flags);
5065 internal->p_offset = BYTE_GET (external->p_offset);
5066 internal->p_vaddr = BYTE_GET (external->p_vaddr);
5067 internal->p_paddr = BYTE_GET (external->p_paddr);
5068 internal->p_filesz = BYTE_GET (external->p_filesz);
5069 internal->p_memsz = BYTE_GET (external->p_memsz);
5070 internal->p_align = BYTE_GET (external->p_align);
5071 }
5072
5073 free (phdrs);
5074 return TRUE;
5075 }
5076
5077 /* Returns TRUE if the program headers were read into `program_headers'. */
5078
5079 static bfd_boolean
5080 get_program_headers (Filedata * filedata)
5081 {
5082 Elf_Internal_Phdr * phdrs;
5083
5084 /* Check cache of prior read. */
5085 if (filedata->program_headers != NULL)
5086 return TRUE;
5087
5088 /* Be kind to memory checkers by looking for
5089 e_phnum values which we know must be invalid. */
5090 if (filedata->file_header.e_phnum
5091 * (is_32bit_elf ? sizeof (Elf32_External_Phdr) : sizeof (Elf64_External_Phdr))
5092 >= filedata->file_size)
5093 {
5094 error (_("Too many program headers - %#x - the file is not that big\n"),
5095 filedata->file_header.e_phnum);
5096 return FALSE;
5097 }
5098
5099 phdrs = (Elf_Internal_Phdr *) cmalloc (filedata->file_header.e_phnum,
5100 sizeof (Elf_Internal_Phdr));
5101 if (phdrs == NULL)
5102 {
5103 error (_("Out of memory reading %u program headers\n"),
5104 filedata->file_header.e_phnum);
5105 return FALSE;
5106 }
5107
5108 if (is_32bit_elf
5109 ? get_32bit_program_headers (filedata, phdrs)
5110 : get_64bit_program_headers (filedata, phdrs))
5111 {
5112 filedata->program_headers = phdrs;
5113 return TRUE;
5114 }
5115
5116 free (phdrs);
5117 return FALSE;
5118 }
5119
5120 /* Returns TRUE if the program headers were loaded. */
5121
5122 static bfd_boolean
5123 process_program_headers (Filedata * filedata)
5124 {
5125 Elf_Internal_Phdr * segment;
5126 unsigned int i;
5127 Elf_Internal_Phdr * previous_load = NULL;
5128
5129 dynamic_addr = 0;
5130 dynamic_size = 0;
5131
5132 if (filedata->file_header.e_phnum == 0)
5133 {
5134 /* PR binutils/12467. */
5135 if (filedata->file_header.e_phoff != 0)
5136 {
5137 warn (_("possibly corrupt ELF header - it has a non-zero program"
5138 " header offset, but no program headers\n"));
5139 return FALSE;
5140 }
5141 else if (do_segments)
5142 printf (_("\nThere are no program headers in this file.\n"));
5143 return TRUE;
5144 }
5145
5146 if (do_segments && !do_header)
5147 {
5148 printf (_("\nElf file type is %s\n"), get_file_type (filedata->file_header.e_type));
5149 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata->file_header.e_entry));
5150 printf (ngettext ("There is %d program header, starting at offset %s\n",
5151 "There are %d program headers, starting at offset %s\n",
5152 filedata->file_header.e_phnum),
5153 filedata->file_header.e_phnum,
5154 bfd_vmatoa ("u", filedata->file_header.e_phoff));
5155 }
5156
5157 if (! get_program_headers (filedata))
5158 return TRUE;
5159
5160 if (do_segments)
5161 {
5162 if (filedata->file_header.e_phnum > 1)
5163 printf (_("\nProgram Headers:\n"));
5164 else
5165 printf (_("\nProgram Headers:\n"));
5166
5167 if (is_32bit_elf)
5168 printf
5169 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5170 else if (do_wide)
5171 printf
5172 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5173 else
5174 {
5175 printf
5176 (_(" Type Offset VirtAddr PhysAddr\n"));
5177 printf
5178 (_(" FileSiz MemSiz Flags Align\n"));
5179 }
5180 }
5181
5182 for (i = 0, segment = filedata->program_headers;
5183 i < filedata->file_header.e_phnum;
5184 i++, segment++)
5185 {
5186 if (do_segments)
5187 {
5188 printf (" %-14.14s ", get_segment_type (filedata, segment->p_type));
5189
5190 if (is_32bit_elf)
5191 {
5192 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5193 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
5194 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
5195 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
5196 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
5197 printf ("%c%c%c ",
5198 (segment->p_flags & PF_R ? 'R' : ' '),
5199 (segment->p_flags & PF_W ? 'W' : ' '),
5200 (segment->p_flags & PF_X ? 'E' : ' '));
5201 printf ("%#lx", (unsigned long) segment->p_align);
5202 }
5203 else if (do_wide)
5204 {
5205 if ((unsigned long) segment->p_offset == segment->p_offset)
5206 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5207 else
5208 {
5209 print_vma (segment->p_offset, FULL_HEX);
5210 putchar (' ');
5211 }
5212
5213 print_vma (segment->p_vaddr, FULL_HEX);
5214 putchar (' ');
5215 print_vma (segment->p_paddr, FULL_HEX);
5216 putchar (' ');
5217
5218 if ((unsigned long) segment->p_filesz == segment->p_filesz)
5219 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
5220 else
5221 {
5222 print_vma (segment->p_filesz, FULL_HEX);
5223 putchar (' ');
5224 }
5225
5226 if ((unsigned long) segment->p_memsz == segment->p_memsz)
5227 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
5228 else
5229 {
5230 print_vma (segment->p_memsz, FULL_HEX);
5231 }
5232
5233 printf (" %c%c%c ",
5234 (segment->p_flags & PF_R ? 'R' : ' '),
5235 (segment->p_flags & PF_W ? 'W' : ' '),
5236 (segment->p_flags & PF_X ? 'E' : ' '));
5237
5238 if ((unsigned long) segment->p_align == segment->p_align)
5239 printf ("%#lx", (unsigned long) segment->p_align);
5240 else
5241 {
5242 print_vma (segment->p_align, PREFIX_HEX);
5243 }
5244 }
5245 else
5246 {
5247 print_vma (segment->p_offset, FULL_HEX);
5248 putchar (' ');
5249 print_vma (segment->p_vaddr, FULL_HEX);
5250 putchar (' ');
5251 print_vma (segment->p_paddr, FULL_HEX);
5252 printf ("\n ");
5253 print_vma (segment->p_filesz, FULL_HEX);
5254 putchar (' ');
5255 print_vma (segment->p_memsz, FULL_HEX);
5256 printf (" %c%c%c ",
5257 (segment->p_flags & PF_R ? 'R' : ' '),
5258 (segment->p_flags & PF_W ? 'W' : ' '),
5259 (segment->p_flags & PF_X ? 'E' : ' '));
5260 print_vma (segment->p_align, PREFIX_HEX);
5261 }
5262
5263 putc ('\n', stdout);
5264 }
5265
5266 switch (segment->p_type)
5267 {
5268 case PT_LOAD:
5269 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5270 required by the ELF standard, several programs, including the Linux
5271 kernel, make use of non-ordered segments. */
5272 if (previous_load
5273 && previous_load->p_vaddr > segment->p_vaddr)
5274 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5275 #endif
5276 if (segment->p_memsz < segment->p_filesz)
5277 error (_("the segment's file size is larger than its memory size\n"));
5278 previous_load = segment;
5279 break;
5280
5281 case PT_PHDR:
5282 /* PR 20815 - Verify that the program header is loaded into memory. */
5283 if (i > 0 && previous_load != NULL)
5284 error (_("the PHDR segment must occur before any LOAD segment\n"));
5285 if (filedata->file_header.e_machine != EM_PARISC)
5286 {
5287 unsigned int j;
5288
5289 for (j = 1; j < filedata->file_header.e_phnum; j++)
5290 {
5291 Elf_Internal_Phdr *load = filedata->program_headers + j;
5292 if (load->p_type == PT_LOAD
5293 && load->p_offset <= segment->p_offset
5294 && (load->p_offset + load->p_filesz
5295 >= segment->p_offset + segment->p_filesz)
5296 && load->p_vaddr <= segment->p_vaddr
5297 && (load->p_vaddr + load->p_filesz
5298 >= segment->p_vaddr + segment->p_filesz))
5299 break;
5300 }
5301 if (j == filedata->file_header.e_phnum)
5302 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5303 }
5304 break;
5305
5306 case PT_DYNAMIC:
5307 if (dynamic_addr)
5308 error (_("more than one dynamic segment\n"));
5309
5310 /* By default, assume that the .dynamic section is the first
5311 section in the DYNAMIC segment. */
5312 dynamic_addr = segment->p_offset;
5313 dynamic_size = segment->p_filesz;
5314
5315 /* Try to locate the .dynamic section. If there is
5316 a section header table, we can easily locate it. */
5317 if (filedata->section_headers != NULL)
5318 {
5319 Elf_Internal_Shdr * sec;
5320
5321 sec = find_section (filedata, ".dynamic");
5322 if (sec == NULL || sec->sh_size == 0)
5323 {
5324 /* A corresponding .dynamic section is expected, but on
5325 IA-64/OpenVMS it is OK for it to be missing. */
5326 if (!is_ia64_vms (filedata))
5327 error (_("no .dynamic section in the dynamic segment\n"));
5328 break;
5329 }
5330
5331 if (sec->sh_type == SHT_NOBITS)
5332 {
5333 dynamic_size = 0;
5334 break;
5335 }
5336
5337 dynamic_addr = sec->sh_offset;
5338 dynamic_size = sec->sh_size;
5339
5340 if (dynamic_addr < segment->p_offset
5341 || dynamic_addr > segment->p_offset + segment->p_filesz)
5342 warn (_("the .dynamic section is not contained"
5343 " within the dynamic segment\n"));
5344 else if (dynamic_addr > segment->p_offset)
5345 warn (_("the .dynamic section is not the first section"
5346 " in the dynamic segment.\n"));
5347 }
5348
5349 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5350 segment. Check this after matching against the section headers
5351 so we don't warn on debuginfo file (which have NOBITS .dynamic
5352 sections). */
5353 if (dynamic_addr > filedata->file_size
5354 || dynamic_size > filedata->file_size - dynamic_addr)
5355 {
5356 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5357 dynamic_addr = dynamic_size = 0;
5358 }
5359 break;
5360
5361 case PT_INTERP:
5362 if (fseek (filedata->handle, archive_file_offset + (long) segment->p_offset,
5363 SEEK_SET))
5364 error (_("Unable to find program interpreter name\n"));
5365 else
5366 {
5367 char fmt [32];
5368 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
5369
5370 if (ret >= (int) sizeof (fmt) || ret < 0)
5371 error (_("Internal error: failed to create format string to display program interpreter\n"));
5372
5373 program_interpreter[0] = 0;
5374 if (fscanf (filedata->handle, fmt, program_interpreter) <= 0)
5375 error (_("Unable to read program interpreter name\n"));
5376
5377 if (do_segments)
5378 printf (_(" [Requesting program interpreter: %s]\n"),
5379 program_interpreter);
5380 }
5381 break;
5382 }
5383 }
5384
5385 if (do_segments
5386 && filedata->section_headers != NULL
5387 && filedata->string_table != NULL)
5388 {
5389 printf (_("\n Section to Segment mapping:\n"));
5390 printf (_(" Segment Sections...\n"));
5391
5392 for (i = 0; i < filedata->file_header.e_phnum; i++)
5393 {
5394 unsigned int j;
5395 Elf_Internal_Shdr * section;
5396
5397 segment = filedata->program_headers + i;
5398 section = filedata->section_headers + 1;
5399
5400 printf (" %2.2d ", i);
5401
5402 for (j = 1; j < filedata->file_header.e_shnum; j++, section++)
5403 {
5404 if (!ELF_TBSS_SPECIAL (section, segment)
5405 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
5406 printf ("%s ", printable_section_name (filedata, section));
5407 }
5408
5409 putc ('\n',stdout);
5410 }
5411 }
5412
5413 return TRUE;
5414 }
5415
5416
5417 /* Find the file offset corresponding to VMA by using the program headers. */
5418
5419 static long
5420 offset_from_vma (Filedata * filedata, bfd_vma vma, bfd_size_type size)
5421 {
5422 Elf_Internal_Phdr * seg;
5423
5424 if (! get_program_headers (filedata))
5425 {
5426 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5427 return (long) vma;
5428 }
5429
5430 for (seg = filedata->program_headers;
5431 seg < filedata->program_headers + filedata->file_header.e_phnum;
5432 ++seg)
5433 {
5434 if (seg->p_type != PT_LOAD)
5435 continue;
5436
5437 if (vma >= (seg->p_vaddr & -seg->p_align)
5438 && vma + size <= seg->p_vaddr + seg->p_filesz)
5439 return vma - seg->p_vaddr + seg->p_offset;
5440 }
5441
5442 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5443 (unsigned long) vma);
5444 return (long) vma;
5445 }
5446
5447
5448 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5449 If PROBE is true, this is just a probe and we do not generate any error
5450 messages if the load fails. */
5451
5452 static bfd_boolean
5453 get_32bit_section_headers (Filedata * filedata, bfd_boolean probe)
5454 {
5455 Elf32_External_Shdr * shdrs;
5456 Elf_Internal_Shdr * internal;
5457 unsigned int i;
5458 unsigned int size = filedata->file_header.e_shentsize;
5459 unsigned int num = probe ? 1 : filedata->file_header.e_shnum;
5460
5461 /* PR binutils/17531: Cope with unexpected section header sizes. */
5462 if (size == 0 || num == 0)
5463 return FALSE;
5464 if (size < sizeof * shdrs)
5465 {
5466 if (! probe)
5467 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5468 return FALSE;
5469 }
5470 if (!probe && size > sizeof * shdrs)
5471 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5472
5473 shdrs = (Elf32_External_Shdr *) get_data (NULL, filedata, filedata->file_header.e_shoff,
5474 size, num,
5475 probe ? NULL : _("section headers"));
5476 if (shdrs == NULL)
5477 return FALSE;
5478
5479 free (filedata->section_headers);
5480 filedata->section_headers = (Elf_Internal_Shdr *)
5481 cmalloc (num, sizeof (Elf_Internal_Shdr));
5482 if (filedata->section_headers == NULL)
5483 {
5484 if (!probe)
5485 error (_("Out of memory reading %u section headers\n"), num);
5486 free (shdrs);
5487 return FALSE;
5488 }
5489
5490 for (i = 0, internal = filedata->section_headers;
5491 i < num;
5492 i++, internal++)
5493 {
5494 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5495 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
5496 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5497 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5498 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5499 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5500 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5501 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5502 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5503 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
5504 if (!probe && internal->sh_link > num)
5505 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5506 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5507 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5508 }
5509
5510 free (shdrs);
5511 return TRUE;
5512 }
5513
5514 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5515
5516 static bfd_boolean
5517 get_64bit_section_headers (Filedata * filedata, bfd_boolean probe)
5518 {
5519 Elf64_External_Shdr * shdrs;
5520 Elf_Internal_Shdr * internal;
5521 unsigned int i;
5522 unsigned int size = filedata->file_header.e_shentsize;
5523 unsigned int num = probe ? 1 : filedata->file_header.e_shnum;
5524
5525 /* PR binutils/17531: Cope with unexpected section header sizes. */
5526 if (size == 0 || num == 0)
5527 return FALSE;
5528
5529 if (size < sizeof * shdrs)
5530 {
5531 if (! probe)
5532 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5533 return FALSE;
5534 }
5535
5536 if (! probe && size > sizeof * shdrs)
5537 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5538
5539 shdrs = (Elf64_External_Shdr *) get_data (NULL, filedata,
5540 filedata->file_header.e_shoff,
5541 size, num,
5542 probe ? NULL : _("section headers"));
5543 if (shdrs == NULL)
5544 return FALSE;
5545
5546 free (filedata->section_headers);
5547 filedata->section_headers = (Elf_Internal_Shdr *)
5548 cmalloc (num, sizeof (Elf_Internal_Shdr));
5549 if (filedata->section_headers == NULL)
5550 {
5551 if (! probe)
5552 error (_("Out of memory reading %u section headers\n"), num);
5553 free (shdrs);
5554 return FALSE;
5555 }
5556
5557 for (i = 0, internal = filedata->section_headers;
5558 i < num;
5559 i++, internal++)
5560 {
5561 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5562 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
5563 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5564 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5565 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5566 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
5567 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5568 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5569 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5570 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5571 if (!probe && internal->sh_link > num)
5572 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5573 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5574 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5575 }
5576
5577 free (shdrs);
5578 return TRUE;
5579 }
5580
5581 static Elf_Internal_Sym *
5582 get_32bit_elf_symbols (Filedata * filedata,
5583 Elf_Internal_Shdr * section,
5584 unsigned long * num_syms_return)
5585 {
5586 unsigned long number = 0;
5587 Elf32_External_Sym * esyms = NULL;
5588 Elf_External_Sym_Shndx * shndx = NULL;
5589 Elf_Internal_Sym * isyms = NULL;
5590 Elf_Internal_Sym * psym;
5591 unsigned int j;
5592 elf_section_list * entry;
5593
5594 if (section->sh_size == 0)
5595 {
5596 if (num_syms_return != NULL)
5597 * num_syms_return = 0;
5598 return NULL;
5599 }
5600
5601 /* Run some sanity checks first. */
5602 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5603 {
5604 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5605 printable_section_name (filedata, section),
5606 (unsigned long) section->sh_entsize);
5607 goto exit_point;
5608 }
5609
5610 if (section->sh_size > filedata->file_size)
5611 {
5612 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5613 printable_section_name (filedata, section),
5614 (unsigned long) section->sh_size);
5615 goto exit_point;
5616 }
5617
5618 number = section->sh_size / section->sh_entsize;
5619
5620 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5621 {
5622 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5623 (unsigned long) section->sh_size,
5624 printable_section_name (filedata, section),
5625 (unsigned long) section->sh_entsize);
5626 goto exit_point;
5627 }
5628
5629 esyms = (Elf32_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5630 section->sh_size, _("symbols"));
5631 if (esyms == NULL)
5632 goto exit_point;
5633
5634 shndx = NULL;
5635 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5636 {
5637 if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5638 continue;
5639
5640 if (shndx != NULL)
5641 {
5642 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5643 free (shndx);
5644 }
5645
5646 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5647 entry->hdr->sh_offset,
5648 1, entry->hdr->sh_size,
5649 _("symbol table section indices"));
5650 if (shndx == NULL)
5651 goto exit_point;
5652
5653 /* PR17531: file: heap-buffer-overflow */
5654 if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5655 {
5656 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5657 printable_section_name (filedata, entry->hdr),
5658 (unsigned long) entry->hdr->sh_size,
5659 (unsigned long) section->sh_size);
5660 goto exit_point;
5661 }
5662 }
5663
5664 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5665
5666 if (isyms == NULL)
5667 {
5668 error (_("Out of memory reading %lu symbols\n"),
5669 (unsigned long) number);
5670 goto exit_point;
5671 }
5672
5673 for (j = 0, psym = isyms; j < number; j++, psym++)
5674 {
5675 psym->st_name = BYTE_GET (esyms[j].st_name);
5676 psym->st_value = BYTE_GET (esyms[j].st_value);
5677 psym->st_size = BYTE_GET (esyms[j].st_size);
5678 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5679 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5680 psym->st_shndx
5681 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5682 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5683 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5684 psym->st_info = BYTE_GET (esyms[j].st_info);
5685 psym->st_other = BYTE_GET (esyms[j].st_other);
5686 }
5687
5688 exit_point:
5689 free (shndx);
5690 free (esyms);
5691
5692 if (num_syms_return != NULL)
5693 * num_syms_return = isyms == NULL ? 0 : number;
5694
5695 return isyms;
5696 }
5697
5698 static Elf_Internal_Sym *
5699 get_64bit_elf_symbols (Filedata * filedata,
5700 Elf_Internal_Shdr * section,
5701 unsigned long * num_syms_return)
5702 {
5703 unsigned long number = 0;
5704 Elf64_External_Sym * esyms = NULL;
5705 Elf_External_Sym_Shndx * shndx = NULL;
5706 Elf_Internal_Sym * isyms = NULL;
5707 Elf_Internal_Sym * psym;
5708 unsigned int j;
5709 elf_section_list * entry;
5710
5711 if (section->sh_size == 0)
5712 {
5713 if (num_syms_return != NULL)
5714 * num_syms_return = 0;
5715 return NULL;
5716 }
5717
5718 /* Run some sanity checks first. */
5719 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5720 {
5721 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5722 printable_section_name (filedata, section),
5723 (unsigned long) section->sh_entsize);
5724 goto exit_point;
5725 }
5726
5727 if (section->sh_size > filedata->file_size)
5728 {
5729 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5730 printable_section_name (filedata, section),
5731 (unsigned long) section->sh_size);
5732 goto exit_point;
5733 }
5734
5735 number = section->sh_size / section->sh_entsize;
5736
5737 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5738 {
5739 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5740 (unsigned long) section->sh_size,
5741 printable_section_name (filedata, section),
5742 (unsigned long) section->sh_entsize);
5743 goto exit_point;
5744 }
5745
5746 esyms = (Elf64_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5747 section->sh_size, _("symbols"));
5748 if (!esyms)
5749 goto exit_point;
5750
5751 shndx = NULL;
5752 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5753 {
5754 if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5755 continue;
5756
5757 if (shndx != NULL)
5758 {
5759 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5760 free (shndx);
5761 }
5762
5763 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5764 entry->hdr->sh_offset,
5765 1, entry->hdr->sh_size,
5766 _("symbol table section indices"));
5767 if (shndx == NULL)
5768 goto exit_point;
5769
5770 /* PR17531: file: heap-buffer-overflow */
5771 if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5772 {
5773 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5774 printable_section_name (filedata, entry->hdr),
5775 (unsigned long) entry->hdr->sh_size,
5776 (unsigned long) section->sh_size);
5777 goto exit_point;
5778 }
5779 }
5780
5781 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5782
5783 if (isyms == NULL)
5784 {
5785 error (_("Out of memory reading %lu symbols\n"),
5786 (unsigned long) number);
5787 goto exit_point;
5788 }
5789
5790 for (j = 0, psym = isyms; j < number; j++, psym++)
5791 {
5792 psym->st_name = BYTE_GET (esyms[j].st_name);
5793 psym->st_info = BYTE_GET (esyms[j].st_info);
5794 psym->st_other = BYTE_GET (esyms[j].st_other);
5795 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5796
5797 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5798 psym->st_shndx
5799 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5800 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5801 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5802
5803 psym->st_value = BYTE_GET (esyms[j].st_value);
5804 psym->st_size = BYTE_GET (esyms[j].st_size);
5805 }
5806
5807 exit_point:
5808 free (shndx);
5809 free (esyms);
5810
5811 if (num_syms_return != NULL)
5812 * num_syms_return = isyms == NULL ? 0 : number;
5813
5814 return isyms;
5815 }
5816
5817 static const char *
5818 get_elf_section_flags (Filedata * filedata, bfd_vma sh_flags)
5819 {
5820 static char buff[1024];
5821 char * p = buff;
5822 unsigned int field_size = is_32bit_elf ? 8 : 16;
5823 signed int sindex;
5824 unsigned int size = sizeof (buff) - (field_size + 4 + 1);
5825 bfd_vma os_flags = 0;
5826 bfd_vma proc_flags = 0;
5827 bfd_vma unknown_flags = 0;
5828 static const struct
5829 {
5830 const char * str;
5831 unsigned int len;
5832 }
5833 flags [] =
5834 {
5835 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5836 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5837 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5838 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5839 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5840 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5841 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5842 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5843 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5844 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5845 /* IA-64 specific. */
5846 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5847 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5848 /* IA-64 OpenVMS specific. */
5849 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5850 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5851 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5852 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5853 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5854 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5855 /* Generic. */
5856 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5857 /* SPARC specific. */
5858 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5859 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5860 /* ARM specific. */
5861 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5862 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5863 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5864 /* GNU specific. */
5865 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5866 /* VLE specific. */
5867 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5868 };
5869
5870 if (do_section_details)
5871 {
5872 sprintf (buff, "[%*.*lx]: ",
5873 field_size, field_size, (unsigned long) sh_flags);
5874 p += field_size + 4;
5875 }
5876
5877 while (sh_flags)
5878 {
5879 bfd_vma flag;
5880
5881 flag = sh_flags & - sh_flags;
5882 sh_flags &= ~ flag;
5883
5884 if (do_section_details)
5885 {
5886 switch (flag)
5887 {
5888 case SHF_WRITE: sindex = 0; break;
5889 case SHF_ALLOC: sindex = 1; break;
5890 case SHF_EXECINSTR: sindex = 2; break;
5891 case SHF_MERGE: sindex = 3; break;
5892 case SHF_STRINGS: sindex = 4; break;
5893 case SHF_INFO_LINK: sindex = 5; break;
5894 case SHF_LINK_ORDER: sindex = 6; break;
5895 case SHF_OS_NONCONFORMING: sindex = 7; break;
5896 case SHF_GROUP: sindex = 8; break;
5897 case SHF_TLS: sindex = 9; break;
5898 case SHF_EXCLUDE: sindex = 18; break;
5899 case SHF_COMPRESSED: sindex = 20; break;
5900 case SHF_GNU_MBIND: sindex = 24; break;
5901
5902 default:
5903 sindex = -1;
5904 switch (filedata->file_header.e_machine)
5905 {
5906 case EM_IA_64:
5907 if (flag == SHF_IA_64_SHORT)
5908 sindex = 10;
5909 else if (flag == SHF_IA_64_NORECOV)
5910 sindex = 11;
5911 #ifdef BFD64
5912 else if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5913 switch (flag)
5914 {
5915 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5916 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5917 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5918 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5919 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5920 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
5921 default: break;
5922 }
5923 #endif
5924 break;
5925
5926 case EM_386:
5927 case EM_IAMCU:
5928 case EM_X86_64:
5929 case EM_L1OM:
5930 case EM_K1OM:
5931 case EM_OLD_SPARCV9:
5932 case EM_SPARC32PLUS:
5933 case EM_SPARCV9:
5934 case EM_SPARC:
5935 if (flag == SHF_ORDERED)
5936 sindex = 19;
5937 break;
5938
5939 case EM_ARM:
5940 switch (flag)
5941 {
5942 case SHF_ENTRYSECT: sindex = 21; break;
5943 case SHF_ARM_PURECODE: sindex = 22; break;
5944 case SHF_COMDEF: sindex = 23; break;
5945 default: break;
5946 }
5947 break;
5948 case EM_PPC:
5949 if (flag == SHF_PPC_VLE)
5950 sindex = 25;
5951 break;
5952
5953 default:
5954 break;
5955 }
5956 }
5957
5958 if (sindex != -1)
5959 {
5960 if (p != buff + field_size + 4)
5961 {
5962 if (size < (10 + 2))
5963 {
5964 warn (_("Internal error: not enough buffer room for section flag info"));
5965 return _("<unknown>");
5966 }
5967 size -= 2;
5968 *p++ = ',';
5969 *p++ = ' ';
5970 }
5971
5972 size -= flags [sindex].len;
5973 p = stpcpy (p, flags [sindex].str);
5974 }
5975 else if (flag & SHF_MASKOS)
5976 os_flags |= flag;
5977 else if (flag & SHF_MASKPROC)
5978 proc_flags |= flag;
5979 else
5980 unknown_flags |= flag;
5981 }
5982 else
5983 {
5984 switch (flag)
5985 {
5986 case SHF_WRITE: *p = 'W'; break;
5987 case SHF_ALLOC: *p = 'A'; break;
5988 case SHF_EXECINSTR: *p = 'X'; break;
5989 case SHF_MERGE: *p = 'M'; break;
5990 case SHF_STRINGS: *p = 'S'; break;
5991 case SHF_INFO_LINK: *p = 'I'; break;
5992 case SHF_LINK_ORDER: *p = 'L'; break;
5993 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5994 case SHF_GROUP: *p = 'G'; break;
5995 case SHF_TLS: *p = 'T'; break;
5996 case SHF_EXCLUDE: *p = 'E'; break;
5997 case SHF_COMPRESSED: *p = 'C'; break;
5998 case SHF_GNU_MBIND: *p = 'D'; break;
5999
6000 default:
6001 if ((filedata->file_header.e_machine == EM_X86_64
6002 || filedata->file_header.e_machine == EM_L1OM
6003 || filedata->file_header.e_machine == EM_K1OM)
6004 && flag == SHF_X86_64_LARGE)
6005 *p = 'l';
6006 else if (filedata->file_header.e_machine == EM_ARM
6007 && flag == SHF_ARM_PURECODE)
6008 *p = 'y';
6009 else if (filedata->file_header.e_machine == EM_PPC
6010 && flag == SHF_PPC_VLE)
6011 *p = 'v';
6012 else if (flag & SHF_MASKOS)
6013 {
6014 *p = 'o';
6015 sh_flags &= ~ SHF_MASKOS;
6016 }
6017 else if (flag & SHF_MASKPROC)
6018 {
6019 *p = 'p';
6020 sh_flags &= ~ SHF_MASKPROC;
6021 }
6022 else
6023 *p = 'x';
6024 break;
6025 }
6026 p++;
6027 }
6028 }
6029
6030 if (do_section_details)
6031 {
6032 if (os_flags)
6033 {
6034 size -= 5 + field_size;
6035 if (p != buff + field_size + 4)
6036 {
6037 if (size < (2 + 1))
6038 {
6039 warn (_("Internal error: not enough buffer room for section flag info"));
6040 return _("<unknown>");
6041 }
6042 size -= 2;
6043 *p++ = ',';
6044 *p++ = ' ';
6045 }
6046 sprintf (p, "OS (%*.*lx)", field_size, field_size,
6047 (unsigned long) os_flags);
6048 p += 5 + field_size;
6049 }
6050 if (proc_flags)
6051 {
6052 size -= 7 + field_size;
6053 if (p != buff + field_size + 4)
6054 {
6055 if (size < (2 + 1))
6056 {
6057 warn (_("Internal error: not enough buffer room for section flag info"));
6058 return _("<unknown>");
6059 }
6060 size -= 2;
6061 *p++ = ',';
6062 *p++ = ' ';
6063 }
6064 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
6065 (unsigned long) proc_flags);
6066 p += 7 + field_size;
6067 }
6068 if (unknown_flags)
6069 {
6070 size -= 10 + field_size;
6071 if (p != buff + field_size + 4)
6072 {
6073 if (size < (2 + 1))
6074 {
6075 warn (_("Internal error: not enough buffer room for section flag info"));
6076 return _("<unknown>");
6077 }
6078 size -= 2;
6079 *p++ = ',';
6080 *p++ = ' ';
6081 }
6082 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
6083 (unsigned long) unknown_flags);
6084 p += 10 + field_size;
6085 }
6086 }
6087
6088 *p = '\0';
6089 return buff;
6090 }
6091
6092 static unsigned int
6093 get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
6094 {
6095 if (is_32bit_elf)
6096 {
6097 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
6098
6099 if (size < sizeof (* echdr))
6100 {
6101 error (_("Compressed section is too small even for a compression header\n"));
6102 return 0;
6103 }
6104
6105 chdr->ch_type = BYTE_GET (echdr->ch_type);
6106 chdr->ch_size = BYTE_GET (echdr->ch_size);
6107 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
6108 return sizeof (*echdr);
6109 }
6110 else
6111 {
6112 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
6113
6114 if (size < sizeof (* echdr))
6115 {
6116 error (_("Compressed section is too small even for a compression header\n"));
6117 return 0;
6118 }
6119
6120 chdr->ch_type = BYTE_GET (echdr->ch_type);
6121 chdr->ch_size = BYTE_GET (echdr->ch_size);
6122 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
6123 return sizeof (*echdr);
6124 }
6125 }
6126
6127 static bfd_boolean
6128 process_section_headers (Filedata * filedata)
6129 {
6130 Elf_Internal_Shdr * section;
6131 unsigned int i;
6132
6133 filedata->section_headers = NULL;
6134
6135 if (filedata->file_header.e_shnum == 0)
6136 {
6137 /* PR binutils/12467. */
6138 if (filedata->file_header.e_shoff != 0)
6139 {
6140 warn (_("possibly corrupt ELF file header - it has a non-zero"
6141 " section header offset, but no section headers\n"));
6142 return FALSE;
6143 }
6144 else if (do_sections)
6145 printf (_("\nThere are no sections in this file.\n"));
6146
6147 return TRUE;
6148 }
6149
6150 if (do_sections && !do_header)
6151 printf (ngettext ("There is %d section header, "
6152 "starting at offset 0x%lx:\n",
6153 "There are %d section headers, "
6154 "starting at offset 0x%lx:\n",
6155 filedata->file_header.e_shnum),
6156 filedata->file_header.e_shnum,
6157 (unsigned long) filedata->file_header.e_shoff);
6158
6159 if (is_32bit_elf)
6160 {
6161 if (! get_32bit_section_headers (filedata, FALSE))
6162 return FALSE;
6163 }
6164 else
6165 {
6166 if (! get_64bit_section_headers (filedata, FALSE))
6167 return FALSE;
6168 }
6169
6170 /* Read in the string table, so that we have names to display. */
6171 if (filedata->file_header.e_shstrndx != SHN_UNDEF
6172 && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
6173 {
6174 section = filedata->section_headers + filedata->file_header.e_shstrndx;
6175
6176 if (section->sh_size != 0)
6177 {
6178 filedata->string_table = (char *) get_data (NULL, filedata, section->sh_offset,
6179 1, section->sh_size,
6180 _("string table"));
6181
6182 filedata->string_table_length = filedata->string_table != NULL ? section->sh_size : 0;
6183 }
6184 }
6185
6186 /* Scan the sections for the dynamic symbol table
6187 and dynamic string table and debug sections. */
6188 dynamic_symbols = NULL;
6189 dynamic_strings = NULL;
6190 dynamic_syminfo = NULL;
6191 symtab_shndx_list = NULL;
6192
6193 eh_addr_size = is_32bit_elf ? 4 : 8;
6194 switch (filedata->file_header.e_machine)
6195 {
6196 case EM_MIPS:
6197 case EM_MIPS_RS3_LE:
6198 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6199 FDE addresses. However, the ABI also has a semi-official ILP32
6200 variant for which the normal FDE address size rules apply.
6201
6202 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6203 section, where XX is the size of longs in bits. Unfortunately,
6204 earlier compilers provided no way of distinguishing ILP32 objects
6205 from LP64 objects, so if there's any doubt, we should assume that
6206 the official LP64 form is being used. */
6207 if ((filedata->file_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
6208 && find_section (filedata, ".gcc_compiled_long32") == NULL)
6209 eh_addr_size = 8;
6210 break;
6211
6212 case EM_H8_300:
6213 case EM_H8_300H:
6214 switch (filedata->file_header.e_flags & EF_H8_MACH)
6215 {
6216 case E_H8_MACH_H8300:
6217 case E_H8_MACH_H8300HN:
6218 case E_H8_MACH_H8300SN:
6219 case E_H8_MACH_H8300SXN:
6220 eh_addr_size = 2;
6221 break;
6222 case E_H8_MACH_H8300H:
6223 case E_H8_MACH_H8300S:
6224 case E_H8_MACH_H8300SX:
6225 eh_addr_size = 4;
6226 break;
6227 }
6228 break;
6229
6230 case EM_M32C_OLD:
6231 case EM_M32C:
6232 switch (filedata->file_header.e_flags & EF_M32C_CPU_MASK)
6233 {
6234 case EF_M32C_CPU_M16C:
6235 eh_addr_size = 2;
6236 break;
6237 }
6238 break;
6239 }
6240
6241 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6242 do \
6243 { \
6244 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6245 if (section->sh_entsize != expected_entsize) \
6246 { \
6247 char buf[40]; \
6248 sprintf_vma (buf, section->sh_entsize); \
6249 /* Note: coded this way so that there is a single string for \
6250 translation. */ \
6251 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6252 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6253 (unsigned) expected_entsize); \
6254 section->sh_entsize = expected_entsize; \
6255 } \
6256 } \
6257 while (0)
6258
6259 #define CHECK_ENTSIZE(section, i, type) \
6260 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6261 sizeof (Elf64_External_##type))
6262
6263 for (i = 0, section = filedata->section_headers;
6264 i < filedata->file_header.e_shnum;
6265 i++, section++)
6266 {
6267 char * name = SECTION_NAME (section);
6268
6269 if (section->sh_type == SHT_DYNSYM)
6270 {
6271 if (dynamic_symbols != NULL)
6272 {
6273 error (_("File contains multiple dynamic symbol tables\n"));
6274 continue;
6275 }
6276
6277 CHECK_ENTSIZE (section, i, Sym);
6278 dynamic_symbols = GET_ELF_SYMBOLS (filedata, section, & num_dynamic_syms);
6279 }
6280 else if (section->sh_type == SHT_STRTAB
6281 && streq (name, ".dynstr"))
6282 {
6283 if (dynamic_strings != NULL)
6284 {
6285 error (_("File contains multiple dynamic string tables\n"));
6286 continue;
6287 }
6288
6289 dynamic_strings = (char *) get_data (NULL, filedata, section->sh_offset,
6290 1, section->sh_size,
6291 _("dynamic strings"));
6292 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
6293 }
6294 else if (section->sh_type == SHT_SYMTAB_SHNDX)
6295 {
6296 elf_section_list * entry = xmalloc (sizeof * entry);
6297
6298 entry->hdr = section;
6299 entry->next = symtab_shndx_list;
6300 symtab_shndx_list = entry;
6301 }
6302 else if (section->sh_type == SHT_SYMTAB)
6303 CHECK_ENTSIZE (section, i, Sym);
6304 else if (section->sh_type == SHT_GROUP)
6305 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
6306 else if (section->sh_type == SHT_REL)
6307 CHECK_ENTSIZE (section, i, Rel);
6308 else if (section->sh_type == SHT_RELA)
6309 CHECK_ENTSIZE (section, i, Rela);
6310 else if ((do_debugging || do_debug_info || do_debug_abbrevs
6311 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
6312 || do_debug_aranges || do_debug_frames || do_debug_macinfo
6313 || do_debug_str || do_debug_loc || do_debug_ranges
6314 || do_debug_addr || do_debug_cu_index || do_debug_links)
6315 && (const_strneq (name, ".debug_")
6316 || const_strneq (name, ".zdebug_")))
6317 {
6318 if (name[1] == 'z')
6319 name += sizeof (".zdebug_") - 1;
6320 else
6321 name += sizeof (".debug_") - 1;
6322
6323 if (do_debugging
6324 || (do_debug_info && const_strneq (name, "info"))
6325 || (do_debug_info && const_strneq (name, "types"))
6326 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
6327 || (do_debug_lines && strcmp (name, "line") == 0)
6328 || (do_debug_lines && const_strneq (name, "line."))
6329 || (do_debug_pubnames && const_strneq (name, "pubnames"))
6330 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
6331 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
6332 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
6333 || (do_debug_aranges && const_strneq (name, "aranges"))
6334 || (do_debug_ranges && const_strneq (name, "ranges"))
6335 || (do_debug_ranges && const_strneq (name, "rnglists"))
6336 || (do_debug_frames && const_strneq (name, "frame"))
6337 || (do_debug_macinfo && const_strneq (name, "macinfo"))
6338 || (do_debug_macinfo && const_strneq (name, "macro"))
6339 || (do_debug_str && const_strneq (name, "str"))
6340 || (do_debug_loc && const_strneq (name, "loc"))
6341 || (do_debug_loc && const_strneq (name, "loclists"))
6342 || (do_debug_addr && const_strneq (name, "addr"))
6343 || (do_debug_cu_index && const_strneq (name, "cu_index"))
6344 || (do_debug_cu_index && const_strneq (name, "tu_index"))
6345 )
6346 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6347 }
6348 /* Linkonce section to be combined with .debug_info at link time. */
6349 else if ((do_debugging || do_debug_info)
6350 && const_strneq (name, ".gnu.linkonce.wi."))
6351 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6352 else if (do_debug_frames && streq (name, ".eh_frame"))
6353 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6354 else if (do_gdb_index && (streq (name, ".gdb_index")
6355 || streq (name, ".debug_names")))
6356 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6357 /* Trace sections for Itanium VMS. */
6358 else if ((do_debugging || do_trace_info || do_trace_abbrevs
6359 || do_trace_aranges)
6360 && const_strneq (name, ".trace_"))
6361 {
6362 name += sizeof (".trace_") - 1;
6363
6364 if (do_debugging
6365 || (do_trace_info && streq (name, "info"))
6366 || (do_trace_abbrevs && streq (name, "abbrev"))
6367 || (do_trace_aranges && streq (name, "aranges"))
6368 )
6369 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6370 }
6371 else if ((do_debugging || do_debug_links)
6372 && (const_strneq (name, ".gnu_debuglink")
6373 || const_strneq (name, ".gnu_debugaltlink")))
6374 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6375 }
6376
6377 if (! do_sections)
6378 return TRUE;
6379
6380 if (filedata->file_header.e_shnum > 1)
6381 printf (_("\nSection Headers:\n"));
6382 else
6383 printf (_("\nSection Header:\n"));
6384
6385 if (is_32bit_elf)
6386 {
6387 if (do_section_details)
6388 {
6389 printf (_(" [Nr] Name\n"));
6390 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6391 }
6392 else
6393 printf
6394 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6395 }
6396 else if (do_wide)
6397 {
6398 if (do_section_details)
6399 {
6400 printf (_(" [Nr] Name\n"));
6401 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6402 }
6403 else
6404 printf
6405 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6406 }
6407 else
6408 {
6409 if (do_section_details)
6410 {
6411 printf (_(" [Nr] Name\n"));
6412 printf (_(" Type Address Offset Link\n"));
6413 printf (_(" Size EntSize Info Align\n"));
6414 }
6415 else
6416 {
6417 printf (_(" [Nr] Name Type Address Offset\n"));
6418 printf (_(" Size EntSize Flags Link Info Align\n"));
6419 }
6420 }
6421
6422 if (do_section_details)
6423 printf (_(" Flags\n"));
6424
6425 for (i = 0, section = filedata->section_headers;
6426 i < filedata->file_header.e_shnum;
6427 i++, section++)
6428 {
6429 /* Run some sanity checks on the section header. */
6430
6431 /* Check the sh_link field. */
6432 switch (section->sh_type)
6433 {
6434 case SHT_REL:
6435 case SHT_RELA:
6436 if (section->sh_link == 0
6437 && (filedata->file_header.e_type == ET_EXEC
6438 || filedata->file_header.e_type == ET_DYN))
6439 /* A dynamic relocation section where all entries use a
6440 zero symbol index need not specify a symtab section. */
6441 break;
6442 /* Fall through. */
6443 case SHT_SYMTAB_SHNDX:
6444 case SHT_GROUP:
6445 case SHT_HASH:
6446 case SHT_GNU_HASH:
6447 case SHT_GNU_versym:
6448 if (section->sh_link == 0
6449 || section->sh_link >= filedata->file_header.e_shnum
6450 || (filedata->section_headers[section->sh_link].sh_type != SHT_SYMTAB
6451 && filedata->section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6452 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6453 i, section->sh_link);
6454 break;
6455
6456 case SHT_DYNAMIC:
6457 case SHT_SYMTAB:
6458 case SHT_DYNSYM:
6459 case SHT_GNU_verneed:
6460 case SHT_GNU_verdef:
6461 case SHT_GNU_LIBLIST:
6462 if (section->sh_link == 0
6463 || section->sh_link >= filedata->file_header.e_shnum
6464 || filedata->section_headers[section->sh_link].sh_type != SHT_STRTAB)
6465 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6466 i, section->sh_link);
6467 break;
6468
6469 case SHT_INIT_ARRAY:
6470 case SHT_FINI_ARRAY:
6471 case SHT_PREINIT_ARRAY:
6472 if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6473 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6474 i, section->sh_link);
6475 break;
6476
6477 default:
6478 /* FIXME: Add support for target specific section types. */
6479 #if 0 /* Currently we do not check other section types as there are too
6480 many special cases. Stab sections for example have a type
6481 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6482 section. */
6483 if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6484 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6485 i, section->sh_link);
6486 #endif
6487 break;
6488 }
6489
6490 /* Check the sh_info field. */
6491 switch (section->sh_type)
6492 {
6493 case SHT_REL:
6494 case SHT_RELA:
6495 if (section->sh_info == 0
6496 && (filedata->file_header.e_type == ET_EXEC
6497 || filedata->file_header.e_type == ET_DYN))
6498 /* Dynamic relocations apply to segments, so they do not
6499 need to specify the section they relocate. */
6500 break;
6501 if (section->sh_info == 0
6502 || section->sh_info >= filedata->file_header.e_shnum
6503 || (filedata->section_headers[section->sh_info].sh_type != SHT_PROGBITS
6504 && filedata->section_headers[section->sh_info].sh_type != SHT_NOBITS
6505 && filedata->section_headers[section->sh_info].sh_type != SHT_NOTE
6506 && filedata->section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6507 && filedata->section_headers[section->sh_info].sh_type != SHT_FINI_ARRAY
6508 && filedata->section_headers[section->sh_info].sh_type != SHT_PREINIT_ARRAY
6509 /* FIXME: Are other section types valid ? */
6510 && filedata->section_headers[section->sh_info].sh_type < SHT_LOOS))
6511 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6512 i, section->sh_info);
6513 break;
6514
6515 case SHT_DYNAMIC:
6516 case SHT_HASH:
6517 case SHT_SYMTAB_SHNDX:
6518 case SHT_INIT_ARRAY:
6519 case SHT_FINI_ARRAY:
6520 case SHT_PREINIT_ARRAY:
6521 if (section->sh_info != 0)
6522 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6523 i, section->sh_info);
6524 break;
6525
6526 case SHT_GROUP:
6527 case SHT_SYMTAB:
6528 case SHT_DYNSYM:
6529 /* A symbol index - we assume that it is valid. */
6530 break;
6531
6532 default:
6533 /* FIXME: Add support for target specific section types. */
6534 if (section->sh_type == SHT_NOBITS)
6535 /* NOBITS section headers with non-zero sh_info fields can be
6536 created when a binary is stripped of everything but its debug
6537 information. The stripped sections have their headers
6538 preserved but their types set to SHT_NOBITS. So do not check
6539 this type of section. */
6540 ;
6541 else if (section->sh_flags & SHF_INFO_LINK)
6542 {
6543 if (section->sh_info < 1 || section->sh_info >= filedata->file_header.e_shnum)
6544 warn (_("[%2u]: Expected link to another section in info field"), i);
6545 }
6546 else if (section->sh_type < SHT_LOOS
6547 && (section->sh_flags & SHF_GNU_MBIND) == 0
6548 && section->sh_info != 0)
6549 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6550 i, section->sh_info);
6551 break;
6552 }
6553
6554 /* Check the sh_size field. */
6555 if (section->sh_size > filedata->file_size
6556 && section->sh_type != SHT_NOBITS
6557 && section->sh_type != SHT_NULL
6558 && section->sh_type < SHT_LOOS)
6559 warn (_("Size of section %u is larger than the entire file!\n"), i);
6560
6561 printf (" [%2u] ", i);
6562 if (do_section_details)
6563 printf ("%s\n ", printable_section_name (filedata, section));
6564 else
6565 print_symbol (-17, SECTION_NAME (section));
6566
6567 printf (do_wide ? " %-15s " : " %-15.15s ",
6568 get_section_type_name (filedata, section->sh_type));
6569
6570 if (is_32bit_elf)
6571 {
6572 const char * link_too_big = NULL;
6573
6574 print_vma (section->sh_addr, LONG_HEX);
6575
6576 printf ( " %6.6lx %6.6lx %2.2lx",
6577 (unsigned long) section->sh_offset,
6578 (unsigned long) section->sh_size,
6579 (unsigned long) section->sh_entsize);
6580
6581 if (do_section_details)
6582 fputs (" ", stdout);
6583 else
6584 printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6585
6586 if (section->sh_link >= filedata->file_header.e_shnum)
6587 {
6588 link_too_big = "";
6589 /* The sh_link value is out of range. Normally this indicates
6590 an error but it can have special values in Solaris binaries. */
6591 switch (filedata->file_header.e_machine)
6592 {
6593 case EM_386:
6594 case EM_IAMCU:
6595 case EM_X86_64:
6596 case EM_L1OM:
6597 case EM_K1OM:
6598 case EM_OLD_SPARCV9:
6599 case EM_SPARC32PLUS:
6600 case EM_SPARCV9:
6601 case EM_SPARC:
6602 if (section->sh_link == (SHN_BEFORE & 0xffff))
6603 link_too_big = "BEFORE";
6604 else if (section->sh_link == (SHN_AFTER & 0xffff))
6605 link_too_big = "AFTER";
6606 break;
6607 default:
6608 break;
6609 }
6610 }
6611
6612 if (do_section_details)
6613 {
6614 if (link_too_big != NULL && * link_too_big)
6615 printf ("<%s> ", link_too_big);
6616 else
6617 printf ("%2u ", section->sh_link);
6618 printf ("%3u %2lu\n", section->sh_info,
6619 (unsigned long) section->sh_addralign);
6620 }
6621 else
6622 printf ("%2u %3u %2lu\n",
6623 section->sh_link,
6624 section->sh_info,
6625 (unsigned long) section->sh_addralign);
6626
6627 if (link_too_big && ! * link_too_big)
6628 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6629 i, section->sh_link);
6630 }
6631 else if (do_wide)
6632 {
6633 print_vma (section->sh_addr, LONG_HEX);
6634
6635 if ((long) section->sh_offset == section->sh_offset)
6636 printf (" %6.6lx", (unsigned long) section->sh_offset);
6637 else
6638 {
6639 putchar (' ');
6640 print_vma (section->sh_offset, LONG_HEX);
6641 }
6642
6643 if ((unsigned long) section->sh_size == section->sh_size)
6644 printf (" %6.6lx", (unsigned long) section->sh_size);
6645 else
6646 {
6647 putchar (' ');
6648 print_vma (section->sh_size, LONG_HEX);
6649 }
6650
6651 if ((unsigned long) section->sh_entsize == section->sh_entsize)
6652 printf (" %2.2lx", (unsigned long) section->sh_entsize);
6653 else
6654 {
6655 putchar (' ');
6656 print_vma (section->sh_entsize, LONG_HEX);
6657 }
6658
6659 if (do_section_details)
6660 fputs (" ", stdout);
6661 else
6662 printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6663
6664 printf ("%2u %3u ", section->sh_link, section->sh_info);
6665
6666 if ((unsigned long) section->sh_addralign == section->sh_addralign)
6667 printf ("%2lu\n", (unsigned long) section->sh_addralign);
6668 else
6669 {
6670 print_vma (section->sh_addralign, DEC);
6671 putchar ('\n');
6672 }
6673 }
6674 else if (do_section_details)
6675 {
6676 putchar (' ');
6677 print_vma (section->sh_addr, LONG_HEX);
6678 if ((long) section->sh_offset == section->sh_offset)
6679 printf (" %16.16lx", (unsigned long) section->sh_offset);
6680 else
6681 {
6682 printf (" ");
6683 print_vma (section->sh_offset, LONG_HEX);
6684 }
6685 printf (" %u\n ", section->sh_link);
6686 print_vma (section->sh_size, LONG_HEX);
6687 putchar (' ');
6688 print_vma (section->sh_entsize, LONG_HEX);
6689
6690 printf (" %-16u %lu\n",
6691 section->sh_info,
6692 (unsigned long) section->sh_addralign);
6693 }
6694 else
6695 {
6696 putchar (' ');
6697 print_vma (section->sh_addr, LONG_HEX);
6698 if ((long) section->sh_offset == section->sh_offset)
6699 printf (" %8.8lx", (unsigned long) section->sh_offset);
6700 else
6701 {
6702 printf (" ");
6703 print_vma (section->sh_offset, LONG_HEX);
6704 }
6705 printf ("\n ");
6706 print_vma (section->sh_size, LONG_HEX);
6707 printf (" ");
6708 print_vma (section->sh_entsize, LONG_HEX);
6709
6710 printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6711
6712 printf (" %2u %3u %lu\n",
6713 section->sh_link,
6714 section->sh_info,
6715 (unsigned long) section->sh_addralign);
6716 }
6717
6718 if (do_section_details)
6719 {
6720 printf (" %s\n", get_elf_section_flags (filedata, section->sh_flags));
6721 if ((section->sh_flags & SHF_COMPRESSED) != 0)
6722 {
6723 /* Minimum section size is 12 bytes for 32-bit compression
6724 header + 12 bytes for compressed data header. */
6725 unsigned char buf[24];
6726
6727 assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6728 if (get_data (&buf, filedata, section->sh_offset, 1,
6729 sizeof (buf), _("compression header")))
6730 {
6731 Elf_Internal_Chdr chdr;
6732
6733 (void) get_compression_header (&chdr, buf, sizeof (buf));
6734
6735 if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6736 printf (" ZLIB, ");
6737 else
6738 printf (_(" [<unknown>: 0x%x], "),
6739 chdr.ch_type);
6740 print_vma (chdr.ch_size, LONG_HEX);
6741 printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6742 }
6743 }
6744 }
6745 }
6746
6747 if (!do_section_details)
6748 {
6749 /* The ordering of the letters shown here matches the ordering of the
6750 corresponding SHF_xxx values, and hence the order in which these
6751 letters will be displayed to the user. */
6752 printf (_("Key to Flags:\n\
6753 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6754 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6755 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6756 if (filedata->file_header.e_machine == EM_X86_64
6757 || filedata->file_header.e_machine == EM_L1OM
6758 || filedata->file_header.e_machine == EM_K1OM)
6759 printf (_("l (large), "));
6760 else if (filedata->file_header.e_machine == EM_ARM)
6761 printf (_("y (purecode), "));
6762 else if (filedata->file_header.e_machine == EM_PPC)
6763 printf (_("v (VLE), "));
6764 printf ("p (processor specific)\n");
6765 }
6766
6767 return TRUE;
6768 }
6769
6770 static const char *
6771 get_group_flags (unsigned int flags)
6772 {
6773 static char buff[128];
6774
6775 if (flags == 0)
6776 return "";
6777 else if (flags == GRP_COMDAT)
6778 return "COMDAT ";
6779
6780 snprintf (buff, 14, _("[0x%x: "), flags);
6781
6782 flags &= ~ GRP_COMDAT;
6783 if (flags & GRP_MASKOS)
6784 {
6785 strcat (buff, "<OS specific>");
6786 flags &= ~ GRP_MASKOS;
6787 }
6788
6789 if (flags & GRP_MASKPROC)
6790 {
6791 strcat (buff, "<PROC specific>");
6792 flags &= ~ GRP_MASKPROC;
6793 }
6794
6795 if (flags)
6796 strcat (buff, "<unknown>");
6797
6798 strcat (buff, "]");
6799 return buff;
6800 }
6801
6802 static bfd_boolean
6803 process_section_groups (Filedata * filedata)
6804 {
6805 Elf_Internal_Shdr * section;
6806 unsigned int i;
6807 struct group * group;
6808 Elf_Internal_Shdr * symtab_sec;
6809 Elf_Internal_Shdr * strtab_sec;
6810 Elf_Internal_Sym * symtab;
6811 unsigned long num_syms;
6812 char * strtab;
6813 size_t strtab_size;
6814
6815 /* Don't process section groups unless needed. */
6816 if (!do_unwind && !do_section_groups)
6817 return TRUE;
6818
6819 if (filedata->file_header.e_shnum == 0)
6820 {
6821 if (do_section_groups)
6822 printf (_("\nThere are no sections to group in this file.\n"));
6823
6824 return TRUE;
6825 }
6826
6827 if (filedata->section_headers == NULL)
6828 {
6829 error (_("Section headers are not available!\n"));
6830 /* PR 13622: This can happen with a corrupt ELF header. */
6831 return FALSE;
6832 }
6833
6834 section_headers_groups = (struct group **) calloc (filedata->file_header.e_shnum,
6835 sizeof (struct group *));
6836
6837 if (section_headers_groups == NULL)
6838 {
6839 error (_("Out of memory reading %u section group headers\n"),
6840 filedata->file_header.e_shnum);
6841 return FALSE;
6842 }
6843
6844 /* Scan the sections for the group section. */
6845 group_count = 0;
6846 for (i = 0, section = filedata->section_headers;
6847 i < filedata->file_header.e_shnum;
6848 i++, section++)
6849 if (section->sh_type == SHT_GROUP)
6850 group_count++;
6851
6852 if (group_count == 0)
6853 {
6854 if (do_section_groups)
6855 printf (_("\nThere are no section groups in this file.\n"));
6856
6857 return TRUE;
6858 }
6859
6860 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6861
6862 if (section_groups == NULL)
6863 {
6864 error (_("Out of memory reading %lu groups\n"),
6865 (unsigned long) group_count);
6866 return FALSE;
6867 }
6868
6869 symtab_sec = NULL;
6870 strtab_sec = NULL;
6871 symtab = NULL;
6872 num_syms = 0;
6873 strtab = NULL;
6874 strtab_size = 0;
6875 for (i = 0, section = filedata->section_headers, group = section_groups;
6876 i < filedata->file_header.e_shnum;
6877 i++, section++)
6878 {
6879 if (section->sh_type == SHT_GROUP)
6880 {
6881 const char * name = printable_section_name (filedata, section);
6882 const char * group_name;
6883 unsigned char * start;
6884 unsigned char * indices;
6885 unsigned int entry, j, size;
6886 Elf_Internal_Shdr * sec;
6887 Elf_Internal_Sym * sym;
6888
6889 /* Get the symbol table. */
6890 if (section->sh_link >= filedata->file_header.e_shnum
6891 || ((sec = filedata->section_headers + section->sh_link)->sh_type
6892 != SHT_SYMTAB))
6893 {
6894 error (_("Bad sh_link in group section `%s'\n"), name);
6895 continue;
6896 }
6897
6898 if (symtab_sec != sec)
6899 {
6900 symtab_sec = sec;
6901 if (symtab)
6902 free (symtab);
6903 symtab = GET_ELF_SYMBOLS (filedata, symtab_sec, & num_syms);
6904 }
6905
6906 if (symtab == NULL)
6907 {
6908 error (_("Corrupt header in group section `%s'\n"), name);
6909 continue;
6910 }
6911
6912 if (section->sh_info >= num_syms)
6913 {
6914 error (_("Bad sh_info in group section `%s'\n"), name);
6915 continue;
6916 }
6917
6918 sym = symtab + section->sh_info;
6919
6920 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6921 {
6922 if (sym->st_shndx == 0
6923 || sym->st_shndx >= filedata->file_header.e_shnum)
6924 {
6925 error (_("Bad sh_info in group section `%s'\n"), name);
6926 continue;
6927 }
6928
6929 group_name = SECTION_NAME (filedata->section_headers + sym->st_shndx);
6930 strtab_sec = NULL;
6931 if (strtab)
6932 free (strtab);
6933 strtab = NULL;
6934 strtab_size = 0;
6935 }
6936 else
6937 {
6938 /* Get the string table. */
6939 if (symtab_sec->sh_link >= filedata->file_header.e_shnum)
6940 {
6941 strtab_sec = NULL;
6942 if (strtab)
6943 free (strtab);
6944 strtab = NULL;
6945 strtab_size = 0;
6946 }
6947 else if (strtab_sec
6948 != (sec = filedata->section_headers + symtab_sec->sh_link))
6949 {
6950 strtab_sec = sec;
6951 if (strtab)
6952 free (strtab);
6953
6954 strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
6955 1, strtab_sec->sh_size,
6956 _("string table"));
6957 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6958 }
6959 group_name = sym->st_name < strtab_size
6960 ? strtab + sym->st_name : _("<corrupt>");
6961 }
6962
6963 /* PR 17531: file: loop. */
6964 if (section->sh_entsize > section->sh_size)
6965 {
6966 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6967 printable_section_name (filedata, section),
6968 (unsigned long) section->sh_entsize,
6969 (unsigned long) section->sh_size);
6970 continue;
6971 }
6972
6973 start = (unsigned char *) get_data (NULL, filedata, section->sh_offset,
6974 1, section->sh_size,
6975 _("section data"));
6976 if (start == NULL)
6977 continue;
6978
6979 indices = start;
6980 size = (section->sh_size / section->sh_entsize) - 1;
6981 entry = byte_get (indices, 4);
6982 indices += 4;
6983
6984 if (do_section_groups)
6985 {
6986 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6987 get_group_flags (entry), i, name, group_name, size);
6988
6989 printf (_(" [Index] Name\n"));
6990 }
6991
6992 group->group_index = i;
6993
6994 for (j = 0; j < size; j++)
6995 {
6996 struct group_list * g;
6997
6998 entry = byte_get (indices, 4);
6999 indices += 4;
7000
7001 if (entry >= filedata->file_header.e_shnum)
7002 {
7003 static unsigned num_group_errors = 0;
7004
7005 if (num_group_errors ++ < 10)
7006 {
7007 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
7008 entry, i, filedata->file_header.e_shnum - 1);
7009 if (num_group_errors == 10)
7010 warn (_("Further error messages about overlarge group section indices suppressed\n"));
7011 }
7012 continue;
7013 }
7014
7015 if (section_headers_groups [entry] != NULL)
7016 {
7017 if (entry)
7018 {
7019 static unsigned num_errs = 0;
7020
7021 if (num_errs ++ < 10)
7022 {
7023 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
7024 entry, i,
7025 section_headers_groups [entry]->group_index);
7026 if (num_errs == 10)
7027 warn (_("Further error messages about already contained group sections suppressed\n"));
7028 }
7029 continue;
7030 }
7031 else
7032 {
7033 /* Intel C/C++ compiler may put section 0 in a
7034 section group. We just warn it the first time
7035 and ignore it afterwards. */
7036 static bfd_boolean warned = FALSE;
7037 if (!warned)
7038 {
7039 error (_("section 0 in group section [%5u]\n"),
7040 section_headers_groups [entry]->group_index);
7041 warned = TRUE;
7042 }
7043 }
7044 }
7045
7046 section_headers_groups [entry] = group;
7047
7048 if (do_section_groups)
7049 {
7050 sec = filedata->section_headers + entry;
7051 printf (" [%5u] %s\n", entry, printable_section_name (filedata, sec));
7052 }
7053
7054 g = (struct group_list *) xmalloc (sizeof (struct group_list));
7055 g->section_index = entry;
7056 g->next = group->root;
7057 group->root = g;
7058 }
7059
7060 if (start)
7061 free (start);
7062
7063 group++;
7064 }
7065 }
7066
7067 if (symtab)
7068 free (symtab);
7069 if (strtab)
7070 free (strtab);
7071 return TRUE;
7072 }
7073
7074 /* Data used to display dynamic fixups. */
7075
7076 struct ia64_vms_dynfixup
7077 {
7078 bfd_vma needed_ident; /* Library ident number. */
7079 bfd_vma needed; /* Index in the dstrtab of the library name. */
7080 bfd_vma fixup_needed; /* Index of the library. */
7081 bfd_vma fixup_rela_cnt; /* Number of fixups. */
7082 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
7083 };
7084
7085 /* Data used to display dynamic relocations. */
7086
7087 struct ia64_vms_dynimgrela
7088 {
7089 bfd_vma img_rela_cnt; /* Number of relocations. */
7090 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
7091 };
7092
7093 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7094 library). */
7095
7096 static bfd_boolean
7097 dump_ia64_vms_dynamic_fixups (Filedata * filedata,
7098 struct ia64_vms_dynfixup * fixup,
7099 const char * strtab,
7100 unsigned int strtab_sz)
7101 {
7102 Elf64_External_VMS_IMAGE_FIXUP * imfs;
7103 long i;
7104 const char * lib_name;
7105
7106 imfs = get_data (NULL, filedata, dynamic_addr + fixup->fixup_rela_off,
7107 1, fixup->fixup_rela_cnt * sizeof (*imfs),
7108 _("dynamic section image fixups"));
7109 if (!imfs)
7110 return FALSE;
7111
7112 if (fixup->needed < strtab_sz)
7113 lib_name = strtab + fixup->needed;
7114 else
7115 {
7116 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7117 (unsigned long) fixup->needed);
7118 lib_name = "???";
7119 }
7120 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7121 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
7122 printf
7123 (_("Seg Offset Type SymVec DataType\n"));
7124
7125 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
7126 {
7127 unsigned int type;
7128 const char *rtype;
7129
7130 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
7131 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
7132 type = BYTE_GET (imfs [i].type);
7133 rtype = elf_ia64_reloc_type (type);
7134 if (rtype == NULL)
7135 printf (" 0x%08x ", type);
7136 else
7137 printf (" %-32s ", rtype);
7138 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
7139 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
7140 }
7141
7142 free (imfs);
7143 return TRUE;
7144 }
7145
7146 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7147
7148 static bfd_boolean
7149 dump_ia64_vms_dynamic_relocs (Filedata * filedata, struct ia64_vms_dynimgrela *imgrela)
7150 {
7151 Elf64_External_VMS_IMAGE_RELA *imrs;
7152 long i;
7153
7154 imrs = get_data (NULL, filedata, dynamic_addr + imgrela->img_rela_off,
7155 1, imgrela->img_rela_cnt * sizeof (*imrs),
7156 _("dynamic section image relocations"));
7157 if (!imrs)
7158 return FALSE;
7159
7160 printf (_("\nImage relocs\n"));
7161 printf
7162 (_("Seg Offset Type Addend Seg Sym Off\n"));
7163
7164 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
7165 {
7166 unsigned int type;
7167 const char *rtype;
7168
7169 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
7170 printf ("%08" BFD_VMA_FMT "x ",
7171 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
7172 type = BYTE_GET (imrs [i].type);
7173 rtype = elf_ia64_reloc_type (type);
7174 if (rtype == NULL)
7175 printf ("0x%08x ", type);
7176 else
7177 printf ("%-31s ", rtype);
7178 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
7179 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
7180 printf ("%08" BFD_VMA_FMT "x\n",
7181 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
7182 }
7183
7184 free (imrs);
7185 return TRUE;
7186 }
7187
7188 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7189
7190 static bfd_boolean
7191 process_ia64_vms_dynamic_relocs (Filedata * filedata)
7192 {
7193 struct ia64_vms_dynfixup fixup;
7194 struct ia64_vms_dynimgrela imgrela;
7195 Elf_Internal_Dyn *entry;
7196 bfd_vma strtab_off = 0;
7197 bfd_vma strtab_sz = 0;
7198 char *strtab = NULL;
7199 bfd_boolean res = TRUE;
7200
7201 memset (&fixup, 0, sizeof (fixup));
7202 memset (&imgrela, 0, sizeof (imgrela));
7203
7204 /* Note: the order of the entries is specified by the OpenVMS specs. */
7205 for (entry = dynamic_section;
7206 entry < dynamic_section + dynamic_nent;
7207 entry++)
7208 {
7209 switch (entry->d_tag)
7210 {
7211 case DT_IA_64_VMS_STRTAB_OFFSET:
7212 strtab_off = entry->d_un.d_val;
7213 break;
7214 case DT_STRSZ:
7215 strtab_sz = entry->d_un.d_val;
7216 if (strtab == NULL)
7217 strtab = get_data (NULL, filedata, dynamic_addr + strtab_off,
7218 1, strtab_sz, _("dynamic string section"));
7219 break;
7220
7221 case DT_IA_64_VMS_NEEDED_IDENT:
7222 fixup.needed_ident = entry->d_un.d_val;
7223 break;
7224 case DT_NEEDED:
7225 fixup.needed = entry->d_un.d_val;
7226 break;
7227 case DT_IA_64_VMS_FIXUP_NEEDED:
7228 fixup.fixup_needed = entry->d_un.d_val;
7229 break;
7230 case DT_IA_64_VMS_FIXUP_RELA_CNT:
7231 fixup.fixup_rela_cnt = entry->d_un.d_val;
7232 break;
7233 case DT_IA_64_VMS_FIXUP_RELA_OFF:
7234 fixup.fixup_rela_off = entry->d_un.d_val;
7235 if (! dump_ia64_vms_dynamic_fixups (filedata, &fixup, strtab, strtab_sz))
7236 res = FALSE;
7237 break;
7238 case DT_IA_64_VMS_IMG_RELA_CNT:
7239 imgrela.img_rela_cnt = entry->d_un.d_val;
7240 break;
7241 case DT_IA_64_VMS_IMG_RELA_OFF:
7242 imgrela.img_rela_off = entry->d_un.d_val;
7243 if (! dump_ia64_vms_dynamic_relocs (filedata, &imgrela))
7244 res = FALSE;
7245 break;
7246
7247 default:
7248 break;
7249 }
7250 }
7251
7252 if (strtab != NULL)
7253 free (strtab);
7254
7255 return res;
7256 }
7257
7258 static struct
7259 {
7260 const char * name;
7261 int reloc;
7262 int size;
7263 int rela;
7264 }
7265 dynamic_relocations [] =
7266 {
7267 { "REL", DT_REL, DT_RELSZ, FALSE },
7268 { "RELA", DT_RELA, DT_RELASZ, TRUE },
7269 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
7270 };
7271
7272 /* Process the reloc section. */
7273
7274 static bfd_boolean
7275 process_relocs (Filedata * filedata)
7276 {
7277 unsigned long rel_size;
7278 unsigned long rel_offset;
7279
7280 if (!do_reloc)
7281 return TRUE;
7282
7283 if (do_using_dynamic)
7284 {
7285 int is_rela;
7286 const char * name;
7287 bfd_boolean has_dynamic_reloc;
7288 unsigned int i;
7289
7290 has_dynamic_reloc = FALSE;
7291
7292 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7293 {
7294 is_rela = dynamic_relocations [i].rela;
7295 name = dynamic_relocations [i].name;
7296 rel_size = dynamic_info [dynamic_relocations [i].size];
7297 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
7298
7299 if (rel_size)
7300 has_dynamic_reloc = TRUE;
7301
7302 if (is_rela == UNKNOWN)
7303 {
7304 if (dynamic_relocations [i].reloc == DT_JMPREL)
7305 switch (dynamic_info[DT_PLTREL])
7306 {
7307 case DT_REL:
7308 is_rela = FALSE;
7309 break;
7310 case DT_RELA:
7311 is_rela = TRUE;
7312 break;
7313 }
7314 }
7315
7316 if (rel_size)
7317 {
7318 printf
7319 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7320 name, rel_offset, rel_size);
7321
7322 dump_relocations (filedata,
7323 offset_from_vma (filedata, rel_offset, rel_size),
7324 rel_size,
7325 dynamic_symbols, num_dynamic_syms,
7326 dynamic_strings, dynamic_strings_length,
7327 is_rela, TRUE /* is_dynamic */);
7328 }
7329 }
7330
7331 if (is_ia64_vms (filedata))
7332 if (process_ia64_vms_dynamic_relocs (filedata))
7333 has_dynamic_reloc = TRUE;
7334
7335 if (! has_dynamic_reloc)
7336 printf (_("\nThere are no dynamic relocations in this file.\n"));
7337 }
7338 else
7339 {
7340 Elf_Internal_Shdr * section;
7341 unsigned long i;
7342 bfd_boolean found = FALSE;
7343
7344 for (i = 0, section = filedata->section_headers;
7345 i < filedata->file_header.e_shnum;
7346 i++, section++)
7347 {
7348 if ( section->sh_type != SHT_RELA
7349 && section->sh_type != SHT_REL)
7350 continue;
7351
7352 rel_offset = section->sh_offset;
7353 rel_size = section->sh_size;
7354
7355 if (rel_size)
7356 {
7357 Elf_Internal_Shdr * strsec;
7358 int is_rela;
7359 unsigned long num_rela;
7360
7361 printf (_("\nRelocation section "));
7362
7363 if (filedata->string_table == NULL)
7364 printf ("%d", section->sh_name);
7365 else
7366 printf ("'%s'", printable_section_name (filedata, section));
7367
7368 num_rela = rel_size / section->sh_entsize;
7369 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7370 " at offset 0x%lx contains %lu entries:\n",
7371 num_rela),
7372 rel_offset, num_rela);
7373
7374 is_rela = section->sh_type == SHT_RELA;
7375
7376 if (section->sh_link != 0
7377 && section->sh_link < filedata->file_header.e_shnum)
7378 {
7379 Elf_Internal_Shdr * symsec;
7380 Elf_Internal_Sym * symtab;
7381 unsigned long nsyms;
7382 unsigned long strtablen = 0;
7383 char * strtab = NULL;
7384
7385 symsec = filedata->section_headers + section->sh_link;
7386 if (symsec->sh_type != SHT_SYMTAB
7387 && symsec->sh_type != SHT_DYNSYM)
7388 continue;
7389
7390 symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
7391
7392 if (symtab == NULL)
7393 continue;
7394
7395 if (symsec->sh_link != 0
7396 && symsec->sh_link < filedata->file_header.e_shnum)
7397 {
7398 strsec = filedata->section_headers + symsec->sh_link;
7399
7400 strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7401 1, strsec->sh_size,
7402 _("string table"));
7403 strtablen = strtab == NULL ? 0 : strsec->sh_size;
7404 }
7405
7406 dump_relocations (filedata, rel_offset, rel_size,
7407 symtab, nsyms, strtab, strtablen,
7408 is_rela,
7409 symsec->sh_type == SHT_DYNSYM);
7410 if (strtab)
7411 free (strtab);
7412 free (symtab);
7413 }
7414 else
7415 dump_relocations (filedata, rel_offset, rel_size,
7416 NULL, 0, NULL, 0, is_rela,
7417 FALSE /* is_dynamic */);
7418
7419 found = TRUE;
7420 }
7421 }
7422
7423 if (! found)
7424 {
7425 /* Users sometimes forget the -D option, so try to be helpful. */
7426 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7427 {
7428 if (dynamic_info [dynamic_relocations [i].size])
7429 {
7430 printf (_("\nThere are no static relocations in this file."));
7431 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7432
7433 break;
7434 }
7435 }
7436 if (i == ARRAY_SIZE (dynamic_relocations))
7437 printf (_("\nThere are no relocations in this file.\n"));
7438 }
7439 }
7440
7441 return TRUE;
7442 }
7443
7444 /* An absolute address consists of a section and an offset. If the
7445 section is NULL, the offset itself is the address, otherwise, the
7446 address equals to LOAD_ADDRESS(section) + offset. */
7447
7448 struct absaddr
7449 {
7450 unsigned short section;
7451 bfd_vma offset;
7452 };
7453
7454 /* Find the nearest symbol at or below ADDR. Returns the symbol
7455 name, if found, and the offset from the symbol to ADDR. */
7456
7457 static void
7458 find_symbol_for_address (Filedata * filedata,
7459 Elf_Internal_Sym * symtab,
7460 unsigned long nsyms,
7461 const char * strtab,
7462 unsigned long strtab_size,
7463 struct absaddr addr,
7464 const char ** symname,
7465 bfd_vma * offset)
7466 {
7467 bfd_vma dist = 0x100000;
7468 Elf_Internal_Sym * sym;
7469 Elf_Internal_Sym * beg;
7470 Elf_Internal_Sym * end;
7471 Elf_Internal_Sym * best = NULL;
7472
7473 REMOVE_ARCH_BITS (addr.offset);
7474 beg = symtab;
7475 end = symtab + nsyms;
7476
7477 while (beg < end)
7478 {
7479 bfd_vma value;
7480
7481 sym = beg + (end - beg) / 2;
7482
7483 value = sym->st_value;
7484 REMOVE_ARCH_BITS (value);
7485
7486 if (sym->st_name != 0
7487 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
7488 && addr.offset >= value
7489 && addr.offset - value < dist)
7490 {
7491 best = sym;
7492 dist = addr.offset - value;
7493 if (!dist)
7494 break;
7495 }
7496
7497 if (addr.offset < value)
7498 end = sym;
7499 else
7500 beg = sym + 1;
7501 }
7502
7503 if (best)
7504 {
7505 *symname = (best->st_name >= strtab_size
7506 ? _("<corrupt>") : strtab + best->st_name);
7507 *offset = dist;
7508 return;
7509 }
7510
7511 *symname = NULL;
7512 *offset = addr.offset;
7513 }
7514
7515 static /* signed */ int
7516 symcmp (const void *p, const void *q)
7517 {
7518 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7519 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7520
7521 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7522 }
7523
7524 /* Process the unwind section. */
7525
7526 #include "unwind-ia64.h"
7527
7528 struct ia64_unw_table_entry
7529 {
7530 struct absaddr start;
7531 struct absaddr end;
7532 struct absaddr info;
7533 };
7534
7535 struct ia64_unw_aux_info
7536 {
7537 struct ia64_unw_table_entry * table; /* Unwind table. */
7538 unsigned long table_len; /* Length of unwind table. */
7539 unsigned char * info; /* Unwind info. */
7540 unsigned long info_size; /* Size of unwind info. */
7541 bfd_vma info_addr; /* Starting address of unwind info. */
7542 bfd_vma seg_base; /* Starting address of segment. */
7543 Elf_Internal_Sym * symtab; /* The symbol table. */
7544 unsigned long nsyms; /* Number of symbols. */
7545 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7546 unsigned long nfuns; /* Number of entries in funtab. */
7547 char * strtab; /* The string table. */
7548 unsigned long strtab_size; /* Size of string table. */
7549 };
7550
7551 static bfd_boolean
7552 dump_ia64_unwind (Filedata * filedata, struct ia64_unw_aux_info * aux)
7553 {
7554 struct ia64_unw_table_entry * tp;
7555 unsigned long j, nfuns;
7556 int in_body;
7557 bfd_boolean res = TRUE;
7558
7559 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7560 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7561 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7562 aux->funtab[nfuns++] = aux->symtab[j];
7563 aux->nfuns = nfuns;
7564 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7565
7566 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7567 {
7568 bfd_vma stamp;
7569 bfd_vma offset;
7570 const unsigned char * dp;
7571 const unsigned char * head;
7572 const unsigned char * end;
7573 const char * procname;
7574
7575 find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7576 aux->strtab_size, tp->start, &procname, &offset);
7577
7578 fputs ("\n<", stdout);
7579
7580 if (procname)
7581 {
7582 fputs (procname, stdout);
7583
7584 if (offset)
7585 printf ("+%lx", (unsigned long) offset);
7586 }
7587
7588 fputs (">: [", stdout);
7589 print_vma (tp->start.offset, PREFIX_HEX);
7590 fputc ('-', stdout);
7591 print_vma (tp->end.offset, PREFIX_HEX);
7592 printf ("], info at +0x%lx\n",
7593 (unsigned long) (tp->info.offset - aux->seg_base));
7594
7595 /* PR 17531: file: 86232b32. */
7596 if (aux->info == NULL)
7597 continue;
7598
7599 offset = tp->info.offset;
7600 if (tp->info.section)
7601 {
7602 if (tp->info.section >= filedata->file_header.e_shnum)
7603 {
7604 warn (_("Invalid section %u in table entry %ld\n"),
7605 tp->info.section, (long) (tp - aux->table));
7606 res = FALSE;
7607 continue;
7608 }
7609 offset += filedata->section_headers[tp->info.section].sh_addr;
7610 }
7611 offset -= aux->info_addr;
7612 /* PR 17531: file: 0997b4d1. */
7613 if (offset >= aux->info_size
7614 || aux->info_size - offset < 8)
7615 {
7616 warn (_("Invalid offset %lx in table entry %ld\n"),
7617 (long) tp->info.offset, (long) (tp - aux->table));
7618 res = FALSE;
7619 continue;
7620 }
7621
7622 head = aux->info + offset;
7623 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
7624
7625 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7626 (unsigned) UNW_VER (stamp),
7627 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7628 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7629 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
7630 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
7631
7632 if (UNW_VER (stamp) != 1)
7633 {
7634 printf (_("\tUnknown version.\n"));
7635 continue;
7636 }
7637
7638 in_body = 0;
7639 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7640 /* PR 17531: file: 16ceda89. */
7641 if (end > aux->info + aux->info_size)
7642 end = aux->info + aux->info_size;
7643 for (dp = head + 8; dp < end;)
7644 dp = unw_decode (dp, in_body, & in_body, end);
7645 }
7646
7647 free (aux->funtab);
7648
7649 return res;
7650 }
7651
7652 static bfd_boolean
7653 slurp_ia64_unwind_table (Filedata * filedata,
7654 struct ia64_unw_aux_info * aux,
7655 Elf_Internal_Shdr * sec)
7656 {
7657 unsigned long size, nrelas, i;
7658 Elf_Internal_Phdr * seg;
7659 struct ia64_unw_table_entry * tep;
7660 Elf_Internal_Shdr * relsec;
7661 Elf_Internal_Rela * rela;
7662 Elf_Internal_Rela * rp;
7663 unsigned char * table;
7664 unsigned char * tp;
7665 Elf_Internal_Sym * sym;
7666 const char * relname;
7667
7668 aux->table_len = 0;
7669
7670 /* First, find the starting address of the segment that includes
7671 this section: */
7672
7673 if (filedata->file_header.e_phnum)
7674 {
7675 if (! get_program_headers (filedata))
7676 return FALSE;
7677
7678 for (seg = filedata->program_headers;
7679 seg < filedata->program_headers + filedata->file_header.e_phnum;
7680 ++seg)
7681 {
7682 if (seg->p_type != PT_LOAD)
7683 continue;
7684
7685 if (sec->sh_addr >= seg->p_vaddr
7686 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7687 {
7688 aux->seg_base = seg->p_vaddr;
7689 break;
7690 }
7691 }
7692 }
7693
7694 /* Second, build the unwind table from the contents of the unwind section: */
7695 size = sec->sh_size;
7696 table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7697 _("unwind table"));
7698 if (!table)
7699 return FALSE;
7700
7701 aux->table_len = size / (3 * eh_addr_size);
7702 aux->table = (struct ia64_unw_table_entry *)
7703 xcmalloc (aux->table_len, sizeof (aux->table[0]));
7704 tep = aux->table;
7705
7706 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7707 {
7708 tep->start.section = SHN_UNDEF;
7709 tep->end.section = SHN_UNDEF;
7710 tep->info.section = SHN_UNDEF;
7711 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7712 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7713 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7714 tep->start.offset += aux->seg_base;
7715 tep->end.offset += aux->seg_base;
7716 tep->info.offset += aux->seg_base;
7717 }
7718 free (table);
7719
7720 /* Third, apply any relocations to the unwind table: */
7721 for (relsec = filedata->section_headers;
7722 relsec < filedata->section_headers + filedata->file_header.e_shnum;
7723 ++relsec)
7724 {
7725 if (relsec->sh_type != SHT_RELA
7726 || relsec->sh_info >= filedata->file_header.e_shnum
7727 || filedata->section_headers + relsec->sh_info != sec)
7728 continue;
7729
7730 if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
7731 & rela, & nrelas))
7732 {
7733 free (aux->table);
7734 aux->table = NULL;
7735 aux->table_len = 0;
7736 return FALSE;
7737 }
7738
7739 for (rp = rela; rp < rela + nrelas; ++rp)
7740 {
7741 unsigned int sym_ndx;
7742 unsigned int r_type = get_reloc_type (filedata, rp->r_info);
7743 relname = elf_ia64_reloc_type (r_type);
7744
7745 /* PR 17531: file: 9fa67536. */
7746 if (relname == NULL)
7747 {
7748 warn (_("Skipping unknown relocation type: %u\n"), r_type);
7749 continue;
7750 }
7751
7752 if (! const_strneq (relname, "R_IA64_SEGREL"))
7753 {
7754 warn (_("Skipping unexpected relocation type: %s\n"), relname);
7755 continue;
7756 }
7757
7758 i = rp->r_offset / (3 * eh_addr_size);
7759
7760 /* PR 17531: file: 5bc8d9bf. */
7761 if (i >= aux->table_len)
7762 {
7763 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7764 continue;
7765 }
7766
7767 sym_ndx = get_reloc_symindex (rp->r_info);
7768 if (sym_ndx >= aux->nsyms)
7769 {
7770 warn (_("Skipping reloc with invalid symbol index: %u\n"),
7771 sym_ndx);
7772 continue;
7773 }
7774 sym = aux->symtab + sym_ndx;
7775
7776 switch (rp->r_offset / eh_addr_size % 3)
7777 {
7778 case 0:
7779 aux->table[i].start.section = sym->st_shndx;
7780 aux->table[i].start.offset = rp->r_addend + sym->st_value;
7781 break;
7782 case 1:
7783 aux->table[i].end.section = sym->st_shndx;
7784 aux->table[i].end.offset = rp->r_addend + sym->st_value;
7785 break;
7786 case 2:
7787 aux->table[i].info.section = sym->st_shndx;
7788 aux->table[i].info.offset = rp->r_addend + sym->st_value;
7789 break;
7790 default:
7791 break;
7792 }
7793 }
7794
7795 free (rela);
7796 }
7797
7798 return TRUE;
7799 }
7800
7801 static bfd_boolean
7802 ia64_process_unwind (Filedata * filedata)
7803 {
7804 Elf_Internal_Shdr * sec;
7805 Elf_Internal_Shdr * unwsec = NULL;
7806 Elf_Internal_Shdr * strsec;
7807 unsigned long i, unwcount = 0, unwstart = 0;
7808 struct ia64_unw_aux_info aux;
7809 bfd_boolean res = TRUE;
7810
7811 memset (& aux, 0, sizeof (aux));
7812
7813 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
7814 {
7815 if (sec->sh_type == SHT_SYMTAB
7816 && sec->sh_link < filedata->file_header.e_shnum)
7817 {
7818 aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
7819
7820 strsec = filedata->section_headers + sec->sh_link;
7821 if (aux.strtab != NULL)
7822 {
7823 error (_("Multiple auxillary string tables encountered\n"));
7824 free (aux.strtab);
7825 res = FALSE;
7826 }
7827 aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7828 1, strsec->sh_size,
7829 _("string table"));
7830 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7831 }
7832 else if (sec->sh_type == SHT_IA_64_UNWIND)
7833 unwcount++;
7834 }
7835
7836 if (!unwcount)
7837 printf (_("\nThere are no unwind sections in this file.\n"));
7838
7839 while (unwcount-- > 0)
7840 {
7841 char * suffix;
7842 size_t len, len2;
7843
7844 for (i = unwstart, sec = filedata->section_headers + unwstart, unwsec = NULL;
7845 i < filedata->file_header.e_shnum; ++i, ++sec)
7846 if (sec->sh_type == SHT_IA_64_UNWIND)
7847 {
7848 unwsec = sec;
7849 break;
7850 }
7851 /* We have already counted the number of SHT_IA64_UNWIND
7852 sections so the loop above should never fail. */
7853 assert (unwsec != NULL);
7854
7855 unwstart = i + 1;
7856 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7857
7858 if ((unwsec->sh_flags & SHF_GROUP) != 0)
7859 {
7860 /* We need to find which section group it is in. */
7861 struct group_list * g;
7862
7863 if (section_headers_groups == NULL
7864 || section_headers_groups [i] == NULL)
7865 i = filedata->file_header.e_shnum;
7866 else
7867 {
7868 g = section_headers_groups [i]->root;
7869
7870 for (; g != NULL; g = g->next)
7871 {
7872 sec = filedata->section_headers + g->section_index;
7873
7874 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7875 break;
7876 }
7877
7878 if (g == NULL)
7879 i = filedata->file_header.e_shnum;
7880 }
7881 }
7882 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7883 {
7884 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7885 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7886 suffix = SECTION_NAME (unwsec) + len;
7887 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7888 ++i, ++sec)
7889 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7890 && streq (SECTION_NAME (sec) + len2, suffix))
7891 break;
7892 }
7893 else
7894 {
7895 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7896 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7897 len = sizeof (ELF_STRING_ia64_unwind) - 1;
7898 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7899 suffix = "";
7900 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7901 suffix = SECTION_NAME (unwsec) + len;
7902 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7903 ++i, ++sec)
7904 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7905 && streq (SECTION_NAME (sec) + len2, suffix))
7906 break;
7907 }
7908
7909 if (i == filedata->file_header.e_shnum)
7910 {
7911 printf (_("\nCould not find unwind info section for "));
7912
7913 if (filedata->string_table == NULL)
7914 printf ("%d", unwsec->sh_name);
7915 else
7916 printf ("'%s'", printable_section_name (filedata, unwsec));
7917 }
7918 else
7919 {
7920 aux.info_addr = sec->sh_addr;
7921 aux.info = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1,
7922 sec->sh_size,
7923 _("unwind info"));
7924 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7925
7926 printf (_("\nUnwind section "));
7927
7928 if (filedata->string_table == NULL)
7929 printf ("%d", unwsec->sh_name);
7930 else
7931 printf ("'%s'", printable_section_name (filedata, unwsec));
7932
7933 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7934 (unsigned long) unwsec->sh_offset,
7935 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7936
7937 if (slurp_ia64_unwind_table (filedata, & aux, unwsec)
7938 && aux.table_len > 0)
7939 dump_ia64_unwind (filedata, & aux);
7940
7941 if (aux.table)
7942 free ((char *) aux.table);
7943 if (aux.info)
7944 free ((char *) aux.info);
7945 aux.table = NULL;
7946 aux.info = NULL;
7947 }
7948 }
7949
7950 if (aux.symtab)
7951 free (aux.symtab);
7952 if (aux.strtab)
7953 free ((char *) aux.strtab);
7954
7955 return res;
7956 }
7957
7958 struct hppa_unw_table_entry
7959 {
7960 struct absaddr start;
7961 struct absaddr end;
7962 unsigned int Cannot_unwind:1; /* 0 */
7963 unsigned int Millicode:1; /* 1 */
7964 unsigned int Millicode_save_sr0:1; /* 2 */
7965 unsigned int Region_description:2; /* 3..4 */
7966 unsigned int reserved1:1; /* 5 */
7967 unsigned int Entry_SR:1; /* 6 */
7968 unsigned int Entry_FR:4; /* Number saved 7..10 */
7969 unsigned int Entry_GR:5; /* Number saved 11..15 */
7970 unsigned int Args_stored:1; /* 16 */
7971 unsigned int Variable_Frame:1; /* 17 */
7972 unsigned int Separate_Package_Body:1; /* 18 */
7973 unsigned int Frame_Extension_Millicode:1; /* 19 */
7974 unsigned int Stack_Overflow_Check:1; /* 20 */
7975 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
7976 unsigned int Ada_Region:1; /* 22 */
7977 unsigned int cxx_info:1; /* 23 */
7978 unsigned int cxx_try_catch:1; /* 24 */
7979 unsigned int sched_entry_seq:1; /* 25 */
7980 unsigned int reserved2:1; /* 26 */
7981 unsigned int Save_SP:1; /* 27 */
7982 unsigned int Save_RP:1; /* 28 */
7983 unsigned int Save_MRP_in_frame:1; /* 29 */
7984 unsigned int extn_ptr_defined:1; /* 30 */
7985 unsigned int Cleanup_defined:1; /* 31 */
7986
7987 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
7988 unsigned int HP_UX_interrupt_marker:1; /* 1 */
7989 unsigned int Large_frame:1; /* 2 */
7990 unsigned int Pseudo_SP_Set:1; /* 3 */
7991 unsigned int reserved4:1; /* 4 */
7992 unsigned int Total_frame_size:27; /* 5..31 */
7993 };
7994
7995 struct hppa_unw_aux_info
7996 {
7997 struct hppa_unw_table_entry * table; /* Unwind table. */
7998 unsigned long table_len; /* Length of unwind table. */
7999 bfd_vma seg_base; /* Starting address of segment. */
8000 Elf_Internal_Sym * symtab; /* The symbol table. */
8001 unsigned long nsyms; /* Number of symbols. */
8002 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
8003 unsigned long nfuns; /* Number of entries in funtab. */
8004 char * strtab; /* The string table. */
8005 unsigned long strtab_size; /* Size of string table. */
8006 };
8007
8008 static bfd_boolean
8009 dump_hppa_unwind (Filedata * filedata, struct hppa_unw_aux_info * aux)
8010 {
8011 struct hppa_unw_table_entry * tp;
8012 unsigned long j, nfuns;
8013 bfd_boolean res = TRUE;
8014
8015 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8016 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8017 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8018 aux->funtab[nfuns++] = aux->symtab[j];
8019 aux->nfuns = nfuns;
8020 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8021
8022 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
8023 {
8024 bfd_vma offset;
8025 const char * procname;
8026
8027 find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
8028 aux->strtab_size, tp->start, &procname,
8029 &offset);
8030
8031 fputs ("\n<", stdout);
8032
8033 if (procname)
8034 {
8035 fputs (procname, stdout);
8036
8037 if (offset)
8038 printf ("+%lx", (unsigned long) offset);
8039 }
8040
8041 fputs (">: [", stdout);
8042 print_vma (tp->start.offset, PREFIX_HEX);
8043 fputc ('-', stdout);
8044 print_vma (tp->end.offset, PREFIX_HEX);
8045 printf ("]\n\t");
8046
8047 #define PF(_m) if (tp->_m) printf (#_m " ");
8048 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8049 PF(Cannot_unwind);
8050 PF(Millicode);
8051 PF(Millicode_save_sr0);
8052 /* PV(Region_description); */
8053 PF(Entry_SR);
8054 PV(Entry_FR);
8055 PV(Entry_GR);
8056 PF(Args_stored);
8057 PF(Variable_Frame);
8058 PF(Separate_Package_Body);
8059 PF(Frame_Extension_Millicode);
8060 PF(Stack_Overflow_Check);
8061 PF(Two_Instruction_SP_Increment);
8062 PF(Ada_Region);
8063 PF(cxx_info);
8064 PF(cxx_try_catch);
8065 PF(sched_entry_seq);
8066 PF(Save_SP);
8067 PF(Save_RP);
8068 PF(Save_MRP_in_frame);
8069 PF(extn_ptr_defined);
8070 PF(Cleanup_defined);
8071 PF(MPE_XL_interrupt_marker);
8072 PF(HP_UX_interrupt_marker);
8073 PF(Large_frame);
8074 PF(Pseudo_SP_Set);
8075 PV(Total_frame_size);
8076 #undef PF
8077 #undef PV
8078 }
8079
8080 printf ("\n");
8081
8082 free (aux->funtab);
8083
8084 return res;
8085 }
8086
8087 static bfd_boolean
8088 slurp_hppa_unwind_table (Filedata * filedata,
8089 struct hppa_unw_aux_info * aux,
8090 Elf_Internal_Shdr * sec)
8091 {
8092 unsigned long size, unw_ent_size, nentries, nrelas, i;
8093 Elf_Internal_Phdr * seg;
8094 struct hppa_unw_table_entry * tep;
8095 Elf_Internal_Shdr * relsec;
8096 Elf_Internal_Rela * rela;
8097 Elf_Internal_Rela * rp;
8098 unsigned char * table;
8099 unsigned char * tp;
8100 Elf_Internal_Sym * sym;
8101 const char * relname;
8102
8103 /* First, find the starting address of the segment that includes
8104 this section. */
8105 if (filedata->file_header.e_phnum)
8106 {
8107 if (! get_program_headers (filedata))
8108 return FALSE;
8109
8110 for (seg = filedata->program_headers;
8111 seg < filedata->program_headers + filedata->file_header.e_phnum;
8112 ++seg)
8113 {
8114 if (seg->p_type != PT_LOAD)
8115 continue;
8116
8117 if (sec->sh_addr >= seg->p_vaddr
8118 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
8119 {
8120 aux->seg_base = seg->p_vaddr;
8121 break;
8122 }
8123 }
8124 }
8125
8126 /* Second, build the unwind table from the contents of the unwind
8127 section. */
8128 size = sec->sh_size;
8129 table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
8130 _("unwind table"));
8131 if (!table)
8132 return FALSE;
8133
8134 unw_ent_size = 16;
8135 nentries = size / unw_ent_size;
8136 size = unw_ent_size * nentries;
8137
8138 tep = aux->table = (struct hppa_unw_table_entry *)
8139 xcmalloc (nentries, sizeof (aux->table[0]));
8140
8141 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
8142 {
8143 unsigned int tmp1, tmp2;
8144
8145 tep->start.section = SHN_UNDEF;
8146 tep->end.section = SHN_UNDEF;
8147
8148 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
8149 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
8150 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
8151 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
8152
8153 tep->start.offset += aux->seg_base;
8154 tep->end.offset += aux->seg_base;
8155
8156 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
8157 tep->Millicode = (tmp1 >> 30) & 0x1;
8158 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
8159 tep->Region_description = (tmp1 >> 27) & 0x3;
8160 tep->reserved1 = (tmp1 >> 26) & 0x1;
8161 tep->Entry_SR = (tmp1 >> 25) & 0x1;
8162 tep->Entry_FR = (tmp1 >> 21) & 0xf;
8163 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
8164 tep->Args_stored = (tmp1 >> 15) & 0x1;
8165 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
8166 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
8167 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
8168 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
8169 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
8170 tep->Ada_Region = (tmp1 >> 9) & 0x1;
8171 tep->cxx_info = (tmp1 >> 8) & 0x1;
8172 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
8173 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
8174 tep->reserved2 = (tmp1 >> 5) & 0x1;
8175 tep->Save_SP = (tmp1 >> 4) & 0x1;
8176 tep->Save_RP = (tmp1 >> 3) & 0x1;
8177 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
8178 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
8179 tep->Cleanup_defined = tmp1 & 0x1;
8180
8181 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
8182 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
8183 tep->Large_frame = (tmp2 >> 29) & 0x1;
8184 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
8185 tep->reserved4 = (tmp2 >> 27) & 0x1;
8186 tep->Total_frame_size = tmp2 & 0x7ffffff;
8187 }
8188 free (table);
8189
8190 /* Third, apply any relocations to the unwind table. */
8191 for (relsec = filedata->section_headers;
8192 relsec < filedata->section_headers + filedata->file_header.e_shnum;
8193 ++relsec)
8194 {
8195 if (relsec->sh_type != SHT_RELA
8196 || relsec->sh_info >= filedata->file_header.e_shnum
8197 || filedata->section_headers + relsec->sh_info != sec)
8198 continue;
8199
8200 if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
8201 & rela, & nrelas))
8202 return FALSE;
8203
8204 for (rp = rela; rp < rela + nrelas; ++rp)
8205 {
8206 unsigned int sym_ndx;
8207 unsigned int r_type = get_reloc_type (filedata, rp->r_info);
8208 relname = elf_hppa_reloc_type (r_type);
8209
8210 if (relname == NULL)
8211 {
8212 warn (_("Skipping unknown relocation type: %u\n"), r_type);
8213 continue;
8214 }
8215
8216 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8217 if (! const_strneq (relname, "R_PARISC_SEGREL"))
8218 {
8219 warn (_("Skipping unexpected relocation type: %s\n"), relname);
8220 continue;
8221 }
8222
8223 i = rp->r_offset / unw_ent_size;
8224 if (i >= aux->table_len)
8225 {
8226 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
8227 continue;
8228 }
8229
8230 sym_ndx = get_reloc_symindex (rp->r_info);
8231 if (sym_ndx >= aux->nsyms)
8232 {
8233 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8234 sym_ndx);
8235 continue;
8236 }
8237 sym = aux->symtab + sym_ndx;
8238
8239 switch ((rp->r_offset % unw_ent_size) / 4)
8240 {
8241 case 0:
8242 aux->table[i].start.section = sym->st_shndx;
8243 aux->table[i].start.offset = sym->st_value + rp->r_addend;
8244 break;
8245 case 1:
8246 aux->table[i].end.section = sym->st_shndx;
8247 aux->table[i].end.offset = sym->st_value + rp->r_addend;
8248 break;
8249 default:
8250 break;
8251 }
8252 }
8253
8254 free (rela);
8255 }
8256
8257 aux->table_len = nentries;
8258
8259 return TRUE;
8260 }
8261
8262 static bfd_boolean
8263 hppa_process_unwind (Filedata * filedata)
8264 {
8265 struct hppa_unw_aux_info aux;
8266 Elf_Internal_Shdr * unwsec = NULL;
8267 Elf_Internal_Shdr * strsec;
8268 Elf_Internal_Shdr * sec;
8269 unsigned long i;
8270 bfd_boolean res = TRUE;
8271
8272 if (filedata->string_table == NULL)
8273 return FALSE;
8274
8275 memset (& aux, 0, sizeof (aux));
8276
8277 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8278 {
8279 if (sec->sh_type == SHT_SYMTAB
8280 && sec->sh_link < filedata->file_header.e_shnum)
8281 {
8282 aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
8283
8284 strsec = filedata->section_headers + sec->sh_link;
8285 if (aux.strtab != NULL)
8286 {
8287 error (_("Multiple auxillary string tables encountered\n"));
8288 free (aux.strtab);
8289 res = FALSE;
8290 }
8291 aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
8292 1, strsec->sh_size,
8293 _("string table"));
8294 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8295 }
8296 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8297 unwsec = sec;
8298 }
8299
8300 if (!unwsec)
8301 printf (_("\nThere are no unwind sections in this file.\n"));
8302
8303 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8304 {
8305 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8306 {
8307 unsigned long num_unwind = sec->sh_size / 16;
8308
8309 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8310 "contains %lu entry:\n",
8311 "\nUnwind section '%s' at offset 0x%lx "
8312 "contains %lu entries:\n",
8313 num_unwind),
8314 printable_section_name (filedata, sec),
8315 (unsigned long) sec->sh_offset,
8316 num_unwind);
8317
8318 if (! slurp_hppa_unwind_table (filedata, &aux, sec))
8319 res = FALSE;
8320
8321 if (res && aux.table_len > 0)
8322 {
8323 if (! dump_hppa_unwind (filedata, &aux))
8324 res = FALSE;
8325 }
8326
8327 if (aux.table)
8328 free ((char *) aux.table);
8329 aux.table = NULL;
8330 }
8331 }
8332
8333 if (aux.symtab)
8334 free (aux.symtab);
8335 if (aux.strtab)
8336 free ((char *) aux.strtab);
8337
8338 return res;
8339 }
8340
8341 struct arm_section
8342 {
8343 unsigned char * data; /* The unwind data. */
8344 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
8345 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
8346 unsigned long nrelas; /* The number of relocations. */
8347 unsigned int rel_type; /* REL or RELA ? */
8348 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
8349 };
8350
8351 struct arm_unw_aux_info
8352 {
8353 Filedata * filedata; /* The file containing the unwind sections. */
8354 Elf_Internal_Sym * symtab; /* The file's symbol table. */
8355 unsigned long nsyms; /* Number of symbols. */
8356 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
8357 unsigned long nfuns; /* Number of these symbols. */
8358 char * strtab; /* The file's string table. */
8359 unsigned long strtab_size; /* Size of string table. */
8360 };
8361
8362 static const char *
8363 arm_print_vma_and_name (Filedata * filedata,
8364 struct arm_unw_aux_info * aux,
8365 bfd_vma fn,
8366 struct absaddr addr)
8367 {
8368 const char *procname;
8369 bfd_vma sym_offset;
8370
8371 if (addr.section == SHN_UNDEF)
8372 addr.offset = fn;
8373
8374 find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
8375 aux->strtab_size, addr, &procname,
8376 &sym_offset);
8377
8378 print_vma (fn, PREFIX_HEX);
8379
8380 if (procname)
8381 {
8382 fputs (" <", stdout);
8383 fputs (procname, stdout);
8384
8385 if (sym_offset)
8386 printf ("+0x%lx", (unsigned long) sym_offset);
8387 fputc ('>', stdout);
8388 }
8389
8390 return procname;
8391 }
8392
8393 static void
8394 arm_free_section (struct arm_section *arm_sec)
8395 {
8396 if (arm_sec->data != NULL)
8397 free (arm_sec->data);
8398
8399 if (arm_sec->rela != NULL)
8400 free (arm_sec->rela);
8401 }
8402
8403 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8404 cached section and install SEC instead.
8405 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8406 and return its valued in * WORDP, relocating if necessary.
8407 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8408 relocation's offset in ADDR.
8409 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8410 into the string table of the symbol associated with the reloc. If no
8411 reloc was applied store -1 there.
8412 5) Return TRUE upon success, FALSE otherwise. */
8413
8414 static bfd_boolean
8415 get_unwind_section_word (Filedata * filedata,
8416 struct arm_unw_aux_info * aux,
8417 struct arm_section * arm_sec,
8418 Elf_Internal_Shdr * sec,
8419 bfd_vma word_offset,
8420 unsigned int * wordp,
8421 struct absaddr * addr,
8422 bfd_vma * sym_name)
8423 {
8424 Elf_Internal_Rela *rp;
8425 Elf_Internal_Sym *sym;
8426 const char * relname;
8427 unsigned int word;
8428 bfd_boolean wrapped;
8429
8430 if (sec == NULL || arm_sec == NULL)
8431 return FALSE;
8432
8433 addr->section = SHN_UNDEF;
8434 addr->offset = 0;
8435
8436 if (sym_name != NULL)
8437 *sym_name = (bfd_vma) -1;
8438
8439 /* If necessary, update the section cache. */
8440 if (sec != arm_sec->sec)
8441 {
8442 Elf_Internal_Shdr *relsec;
8443
8444 arm_free_section (arm_sec);
8445
8446 arm_sec->sec = sec;
8447 arm_sec->data = get_data (NULL, aux->filedata, sec->sh_offset, 1,
8448 sec->sh_size, _("unwind data"));
8449 arm_sec->rela = NULL;
8450 arm_sec->nrelas = 0;
8451
8452 for (relsec = filedata->section_headers;
8453 relsec < filedata->section_headers + filedata->file_header.e_shnum;
8454 ++relsec)
8455 {
8456 if (relsec->sh_info >= filedata->file_header.e_shnum
8457 || filedata->section_headers + relsec->sh_info != sec
8458 /* PR 15745: Check the section type as well. */
8459 || (relsec->sh_type != SHT_REL
8460 && relsec->sh_type != SHT_RELA))
8461 continue;
8462
8463 arm_sec->rel_type = relsec->sh_type;
8464 if (relsec->sh_type == SHT_REL)
8465 {
8466 if (!slurp_rel_relocs (aux->filedata, relsec->sh_offset,
8467 relsec->sh_size,
8468 & arm_sec->rela, & arm_sec->nrelas))
8469 return FALSE;
8470 }
8471 else /* relsec->sh_type == SHT_RELA */
8472 {
8473 if (!slurp_rela_relocs (aux->filedata, relsec->sh_offset,
8474 relsec->sh_size,
8475 & arm_sec->rela, & arm_sec->nrelas))
8476 return FALSE;
8477 }
8478 break;
8479 }
8480
8481 arm_sec->next_rela = arm_sec->rela;
8482 }
8483
8484 /* If there is no unwind data we can do nothing. */
8485 if (arm_sec->data == NULL)
8486 return FALSE;
8487
8488 /* If the offset is invalid then fail. */
8489 if (/* PR 21343 *//* PR 18879 */
8490 sec->sh_size < 4
8491 || word_offset > (sec->sh_size - 4)
8492 || ((bfd_signed_vma) word_offset) < 0)
8493 return FALSE;
8494
8495 /* Get the word at the required offset. */
8496 word = byte_get (arm_sec->data + word_offset, 4);
8497
8498 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8499 if (arm_sec->rela == NULL)
8500 {
8501 * wordp = word;
8502 return TRUE;
8503 }
8504
8505 /* Look through the relocs to find the one that applies to the provided offset. */
8506 wrapped = FALSE;
8507 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8508 {
8509 bfd_vma prelval, offset;
8510
8511 if (rp->r_offset > word_offset && !wrapped)
8512 {
8513 rp = arm_sec->rela;
8514 wrapped = TRUE;
8515 }
8516 if (rp->r_offset > word_offset)
8517 break;
8518
8519 if (rp->r_offset & 3)
8520 {
8521 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8522 (unsigned long) rp->r_offset);
8523 continue;
8524 }
8525
8526 if (rp->r_offset < word_offset)
8527 continue;
8528
8529 /* PR 17531: file: 027-161405-0.004 */
8530 if (aux->symtab == NULL)
8531 continue;
8532
8533 if (arm_sec->rel_type == SHT_REL)
8534 {
8535 offset = word & 0x7fffffff;
8536 if (offset & 0x40000000)
8537 offset |= ~ (bfd_vma) 0x7fffffff;
8538 }
8539 else if (arm_sec->rel_type == SHT_RELA)
8540 offset = rp->r_addend;
8541 else
8542 {
8543 error (_("Unknown section relocation type %d encountered\n"),
8544 arm_sec->rel_type);
8545 break;
8546 }
8547
8548 /* PR 17531 file: 027-1241568-0.004. */
8549 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8550 {
8551 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8552 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8553 break;
8554 }
8555
8556 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8557 offset += sym->st_value;
8558 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8559
8560 /* Check that we are processing the expected reloc type. */
8561 if (filedata->file_header.e_machine == EM_ARM)
8562 {
8563 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8564 if (relname == NULL)
8565 {
8566 warn (_("Skipping unknown ARM relocation type: %d\n"),
8567 (int) ELF32_R_TYPE (rp->r_info));
8568 continue;
8569 }
8570
8571 if (streq (relname, "R_ARM_NONE"))
8572 continue;
8573
8574 if (! streq (relname, "R_ARM_PREL31"))
8575 {
8576 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8577 continue;
8578 }
8579 }
8580 else if (filedata->file_header.e_machine == EM_TI_C6000)
8581 {
8582 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8583 if (relname == NULL)
8584 {
8585 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8586 (int) ELF32_R_TYPE (rp->r_info));
8587 continue;
8588 }
8589
8590 if (streq (relname, "R_C6000_NONE"))
8591 continue;
8592
8593 if (! streq (relname, "R_C6000_PREL31"))
8594 {
8595 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8596 continue;
8597 }
8598
8599 prelval >>= 1;
8600 }
8601 else
8602 {
8603 /* This function currently only supports ARM and TI unwinders. */
8604 warn (_("Only TI and ARM unwinders are currently supported\n"));
8605 break;
8606 }
8607
8608 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8609 addr->section = sym->st_shndx;
8610 addr->offset = offset;
8611
8612 if (sym_name)
8613 * sym_name = sym->st_name;
8614 break;
8615 }
8616
8617 *wordp = word;
8618 arm_sec->next_rela = rp;
8619
8620 return TRUE;
8621 }
8622
8623 static const char *tic6x_unwind_regnames[16] =
8624 {
8625 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8626 "A14", "A13", "A12", "A11", "A10",
8627 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8628 };
8629
8630 static void
8631 decode_tic6x_unwind_regmask (unsigned int mask)
8632 {
8633 int i;
8634
8635 for (i = 12; mask; mask >>= 1, i--)
8636 {
8637 if (mask & 1)
8638 {
8639 fputs (tic6x_unwind_regnames[i], stdout);
8640 if (mask > 1)
8641 fputs (", ", stdout);
8642 }
8643 }
8644 }
8645
8646 #define ADVANCE \
8647 if (remaining == 0 && more_words) \
8648 { \
8649 data_offset += 4; \
8650 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8651 data_offset, & word, & addr, NULL)) \
8652 return FALSE; \
8653 remaining = 4; \
8654 more_words--; \
8655 } \
8656
8657 #define GET_OP(OP) \
8658 ADVANCE; \
8659 if (remaining) \
8660 { \
8661 remaining--; \
8662 (OP) = word >> 24; \
8663 word <<= 8; \
8664 } \
8665 else \
8666 { \
8667 printf (_("[Truncated opcode]\n")); \
8668 return FALSE; \
8669 } \
8670 printf ("0x%02x ", OP)
8671
8672 static bfd_boolean
8673 decode_arm_unwind_bytecode (Filedata * filedata,
8674 struct arm_unw_aux_info * aux,
8675 unsigned int word,
8676 unsigned int remaining,
8677 unsigned int more_words,
8678 bfd_vma data_offset,
8679 Elf_Internal_Shdr * data_sec,
8680 struct arm_section * data_arm_sec)
8681 {
8682 struct absaddr addr;
8683 bfd_boolean res = TRUE;
8684
8685 /* Decode the unwinding instructions. */
8686 while (1)
8687 {
8688 unsigned int op, op2;
8689
8690 ADVANCE;
8691 if (remaining == 0)
8692 break;
8693 remaining--;
8694 op = word >> 24;
8695 word <<= 8;
8696
8697 printf (" 0x%02x ", op);
8698
8699 if ((op & 0xc0) == 0x00)
8700 {
8701 int offset = ((op & 0x3f) << 2) + 4;
8702
8703 printf (" vsp = vsp + %d", offset);
8704 }
8705 else if ((op & 0xc0) == 0x40)
8706 {
8707 int offset = ((op & 0x3f) << 2) + 4;
8708
8709 printf (" vsp = vsp - %d", offset);
8710 }
8711 else if ((op & 0xf0) == 0x80)
8712 {
8713 GET_OP (op2);
8714 if (op == 0x80 && op2 == 0)
8715 printf (_("Refuse to unwind"));
8716 else
8717 {
8718 unsigned int mask = ((op & 0x0f) << 8) | op2;
8719 bfd_boolean first = TRUE;
8720 int i;
8721
8722 printf ("pop {");
8723 for (i = 0; i < 12; i++)
8724 if (mask & (1 << i))
8725 {
8726 if (first)
8727 first = FALSE;
8728 else
8729 printf (", ");
8730 printf ("r%d", 4 + i);
8731 }
8732 printf ("}");
8733 }
8734 }
8735 else if ((op & 0xf0) == 0x90)
8736 {
8737 if (op == 0x9d || op == 0x9f)
8738 printf (_(" [Reserved]"));
8739 else
8740 printf (" vsp = r%d", op & 0x0f);
8741 }
8742 else if ((op & 0xf0) == 0xa0)
8743 {
8744 int end = 4 + (op & 0x07);
8745 bfd_boolean first = TRUE;
8746 int i;
8747
8748 printf (" pop {");
8749 for (i = 4; i <= end; i++)
8750 {
8751 if (first)
8752 first = FALSE;
8753 else
8754 printf (", ");
8755 printf ("r%d", i);
8756 }
8757 if (op & 0x08)
8758 {
8759 if (!first)
8760 printf (", ");
8761 printf ("r14");
8762 }
8763 printf ("}");
8764 }
8765 else if (op == 0xb0)
8766 printf (_(" finish"));
8767 else if (op == 0xb1)
8768 {
8769 GET_OP (op2);
8770 if (op2 == 0 || (op2 & 0xf0) != 0)
8771 printf (_("[Spare]"));
8772 else
8773 {
8774 unsigned int mask = op2 & 0x0f;
8775 bfd_boolean first = TRUE;
8776 int i;
8777
8778 printf ("pop {");
8779 for (i = 0; i < 12; i++)
8780 if (mask & (1 << i))
8781 {
8782 if (first)
8783 first = FALSE;
8784 else
8785 printf (", ");
8786 printf ("r%d", i);
8787 }
8788 printf ("}");
8789 }
8790 }
8791 else if (op == 0xb2)
8792 {
8793 unsigned char buf[9];
8794 unsigned int i, len;
8795 unsigned long offset;
8796
8797 for (i = 0; i < sizeof (buf); i++)
8798 {
8799 GET_OP (buf[i]);
8800 if ((buf[i] & 0x80) == 0)
8801 break;
8802 }
8803 if (i == sizeof (buf))
8804 {
8805 error (_("corrupt change to vsp"));
8806 res = FALSE;
8807 }
8808 else
8809 {
8810 offset = read_leb128 (buf, buf + i + 1, FALSE, &len, NULL);
8811 assert (len == i + 1);
8812 offset = offset * 4 + 0x204;
8813 printf ("vsp = vsp + %ld", offset);
8814 }
8815 }
8816 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8817 {
8818 unsigned int first, last;
8819
8820 GET_OP (op2);
8821 first = op2 >> 4;
8822 last = op2 & 0x0f;
8823 if (op == 0xc8)
8824 first = first + 16;
8825 printf ("pop {D%d", first);
8826 if (last)
8827 printf ("-D%d", first + last);
8828 printf ("}");
8829 }
8830 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8831 {
8832 unsigned int count = op & 0x07;
8833
8834 printf ("pop {D8");
8835 if (count)
8836 printf ("-D%d", 8 + count);
8837 printf ("}");
8838 }
8839 else if (op >= 0xc0 && op <= 0xc5)
8840 {
8841 unsigned int count = op & 0x07;
8842
8843 printf (" pop {wR10");
8844 if (count)
8845 printf ("-wR%d", 10 + count);
8846 printf ("}");
8847 }
8848 else if (op == 0xc6)
8849 {
8850 unsigned int first, last;
8851
8852 GET_OP (op2);
8853 first = op2 >> 4;
8854 last = op2 & 0x0f;
8855 printf ("pop {wR%d", first);
8856 if (last)
8857 printf ("-wR%d", first + last);
8858 printf ("}");
8859 }
8860 else if (op == 0xc7)
8861 {
8862 GET_OP (op2);
8863 if (op2 == 0 || (op2 & 0xf0) != 0)
8864 printf (_("[Spare]"));
8865 else
8866 {
8867 unsigned int mask = op2 & 0x0f;
8868 bfd_boolean first = TRUE;
8869 int i;
8870
8871 printf ("pop {");
8872 for (i = 0; i < 4; i++)
8873 if (mask & (1 << i))
8874 {
8875 if (first)
8876 first = FALSE;
8877 else
8878 printf (", ");
8879 printf ("wCGR%d", i);
8880 }
8881 printf ("}");
8882 }
8883 }
8884 else
8885 {
8886 printf (_(" [unsupported opcode]"));
8887 res = FALSE;
8888 }
8889
8890 printf ("\n");
8891 }
8892
8893 return res;
8894 }
8895
8896 static bfd_boolean
8897 decode_tic6x_unwind_bytecode (Filedata * filedata,
8898 struct arm_unw_aux_info * aux,
8899 unsigned int word,
8900 unsigned int remaining,
8901 unsigned int more_words,
8902 bfd_vma data_offset,
8903 Elf_Internal_Shdr * data_sec,
8904 struct arm_section * data_arm_sec)
8905 {
8906 struct absaddr addr;
8907
8908 /* Decode the unwinding instructions. */
8909 while (1)
8910 {
8911 unsigned int op, op2;
8912
8913 ADVANCE;
8914 if (remaining == 0)
8915 break;
8916 remaining--;
8917 op = word >> 24;
8918 word <<= 8;
8919
8920 printf (" 0x%02x ", op);
8921
8922 if ((op & 0xc0) == 0x00)
8923 {
8924 int offset = ((op & 0x3f) << 3) + 8;
8925 printf (" sp = sp + %d", offset);
8926 }
8927 else if ((op & 0xc0) == 0x80)
8928 {
8929 GET_OP (op2);
8930 if (op == 0x80 && op2 == 0)
8931 printf (_("Refuse to unwind"));
8932 else
8933 {
8934 unsigned int mask = ((op & 0x1f) << 8) | op2;
8935 if (op & 0x20)
8936 printf ("pop compact {");
8937 else
8938 printf ("pop {");
8939
8940 decode_tic6x_unwind_regmask (mask);
8941 printf("}");
8942 }
8943 }
8944 else if ((op & 0xf0) == 0xc0)
8945 {
8946 unsigned int reg;
8947 unsigned int nregs;
8948 unsigned int i;
8949 const char *name;
8950 struct
8951 {
8952 unsigned int offset;
8953 unsigned int reg;
8954 } regpos[16];
8955
8956 /* Scan entire instruction first so that GET_OP output is not
8957 interleaved with disassembly. */
8958 nregs = 0;
8959 for (i = 0; nregs < (op & 0xf); i++)
8960 {
8961 GET_OP (op2);
8962 reg = op2 >> 4;
8963 if (reg != 0xf)
8964 {
8965 regpos[nregs].offset = i * 2;
8966 regpos[nregs].reg = reg;
8967 nregs++;
8968 }
8969
8970 reg = op2 & 0xf;
8971 if (reg != 0xf)
8972 {
8973 regpos[nregs].offset = i * 2 + 1;
8974 regpos[nregs].reg = reg;
8975 nregs++;
8976 }
8977 }
8978
8979 printf (_("pop frame {"));
8980 if (nregs == 0)
8981 {
8982 printf (_("*corrupt* - no registers specified"));
8983 }
8984 else
8985 {
8986 reg = nregs - 1;
8987 for (i = i * 2; i > 0; i--)
8988 {
8989 if (regpos[reg].offset == i - 1)
8990 {
8991 name = tic6x_unwind_regnames[regpos[reg].reg];
8992 if (reg > 0)
8993 reg--;
8994 }
8995 else
8996 name = _("[pad]");
8997
8998 fputs (name, stdout);
8999 if (i > 1)
9000 printf (", ");
9001 }
9002 }
9003
9004 printf ("}");
9005 }
9006 else if (op == 0xd0)
9007 printf (" MOV FP, SP");
9008 else if (op == 0xd1)
9009 printf (" __c6xabi_pop_rts");
9010 else if (op == 0xd2)
9011 {
9012 unsigned char buf[9];
9013 unsigned int i, len;
9014 unsigned long offset;
9015
9016 for (i = 0; i < sizeof (buf); i++)
9017 {
9018 GET_OP (buf[i]);
9019 if ((buf[i] & 0x80) == 0)
9020 break;
9021 }
9022 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
9023 if (i == sizeof (buf))
9024 {
9025 warn (_("Corrupt stack pointer adjustment detected\n"));
9026 return FALSE;
9027 }
9028
9029 offset = read_leb128 (buf, buf + i + 1, FALSE, &len, NULL);
9030 assert (len == i + 1);
9031 offset = offset * 8 + 0x408;
9032 printf (_("sp = sp + %ld"), offset);
9033 }
9034 else if ((op & 0xf0) == 0xe0)
9035 {
9036 if ((op & 0x0f) == 7)
9037 printf (" RETURN");
9038 else
9039 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
9040 }
9041 else
9042 {
9043 printf (_(" [unsupported opcode]"));
9044 }
9045 putchar ('\n');
9046 }
9047
9048 return TRUE;
9049 }
9050
9051 static bfd_vma
9052 arm_expand_prel31 (Filedata * filedata, bfd_vma word, bfd_vma where)
9053 {
9054 bfd_vma offset;
9055
9056 offset = word & 0x7fffffff;
9057 if (offset & 0x40000000)
9058 offset |= ~ (bfd_vma) 0x7fffffff;
9059
9060 if (filedata->file_header.e_machine == EM_TI_C6000)
9061 offset <<= 1;
9062
9063 return offset + where;
9064 }
9065
9066 static bfd_boolean
9067 decode_arm_unwind (Filedata * filedata,
9068 struct arm_unw_aux_info * aux,
9069 unsigned int word,
9070 unsigned int remaining,
9071 bfd_vma data_offset,
9072 Elf_Internal_Shdr * data_sec,
9073 struct arm_section * data_arm_sec)
9074 {
9075 int per_index;
9076 unsigned int more_words = 0;
9077 struct absaddr addr;
9078 bfd_vma sym_name = (bfd_vma) -1;
9079 bfd_boolean res = TRUE;
9080
9081 if (remaining == 0)
9082 {
9083 /* Fetch the first word.
9084 Note - when decoding an object file the address extracted
9085 here will always be 0. So we also pass in the sym_name
9086 parameter so that we can find the symbol associated with
9087 the personality routine. */
9088 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, data_offset,
9089 & word, & addr, & sym_name))
9090 return FALSE;
9091
9092 remaining = 4;
9093 }
9094 else
9095 {
9096 addr.section = SHN_UNDEF;
9097 addr.offset = 0;
9098 }
9099
9100 if ((word & 0x80000000) == 0)
9101 {
9102 /* Expand prel31 for personality routine. */
9103 bfd_vma fn;
9104 const char *procname;
9105
9106 fn = arm_expand_prel31 (filedata, word, data_sec->sh_addr + data_offset);
9107 printf (_(" Personality routine: "));
9108 if (fn == 0
9109 && addr.section == SHN_UNDEF && addr.offset == 0
9110 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
9111 {
9112 procname = aux->strtab + sym_name;
9113 print_vma (fn, PREFIX_HEX);
9114 if (procname)
9115 {
9116 fputs (" <", stdout);
9117 fputs (procname, stdout);
9118 fputc ('>', stdout);
9119 }
9120 }
9121 else
9122 procname = arm_print_vma_and_name (filedata, aux, fn, addr);
9123 fputc ('\n', stdout);
9124
9125 /* The GCC personality routines use the standard compact
9126 encoding, starting with one byte giving the number of
9127 words. */
9128 if (procname != NULL
9129 && (const_strneq (procname, "__gcc_personality_v0")
9130 || const_strneq (procname, "__gxx_personality_v0")
9131 || const_strneq (procname, "__gcj_personality_v0")
9132 || const_strneq (procname, "__gnu_objc_personality_v0")))
9133 {
9134 remaining = 0;
9135 more_words = 1;
9136 ADVANCE;
9137 if (!remaining)
9138 {
9139 printf (_(" [Truncated data]\n"));
9140 return FALSE;
9141 }
9142 more_words = word >> 24;
9143 word <<= 8;
9144 remaining--;
9145 per_index = -1;
9146 }
9147 else
9148 return TRUE;
9149 }
9150 else
9151 {
9152 /* ARM EHABI Section 6.3:
9153
9154 An exception-handling table entry for the compact model looks like:
9155
9156 31 30-28 27-24 23-0
9157 -- ----- ----- ----
9158 1 0 index Data for personalityRoutine[index] */
9159
9160 if (filedata->file_header.e_machine == EM_ARM
9161 && (word & 0x70000000))
9162 {
9163 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
9164 res = FALSE;
9165 }
9166
9167 per_index = (word >> 24) & 0x7f;
9168 printf (_(" Compact model index: %d\n"), per_index);
9169 if (per_index == 0)
9170 {
9171 more_words = 0;
9172 word <<= 8;
9173 remaining--;
9174 }
9175 else if (per_index < 3)
9176 {
9177 more_words = (word >> 16) & 0xff;
9178 word <<= 16;
9179 remaining -= 2;
9180 }
9181 }
9182
9183 switch (filedata->file_header.e_machine)
9184 {
9185 case EM_ARM:
9186 if (per_index < 3)
9187 {
9188 if (! decode_arm_unwind_bytecode (filedata, aux, word, remaining, more_words,
9189 data_offset, data_sec, data_arm_sec))
9190 res = FALSE;
9191 }
9192 else
9193 {
9194 warn (_("Unknown ARM compact model index encountered\n"));
9195 printf (_(" [reserved]\n"));
9196 res = FALSE;
9197 }
9198 break;
9199
9200 case EM_TI_C6000:
9201 if (per_index < 3)
9202 {
9203 if (! decode_tic6x_unwind_bytecode (filedata, aux, word, remaining, more_words,
9204 data_offset, data_sec, data_arm_sec))
9205 res = FALSE;
9206 }
9207 else if (per_index < 5)
9208 {
9209 if (((word >> 17) & 0x7f) == 0x7f)
9210 printf (_(" Restore stack from frame pointer\n"));
9211 else
9212 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
9213 printf (_(" Registers restored: "));
9214 if (per_index == 4)
9215 printf (" (compact) ");
9216 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
9217 putchar ('\n');
9218 printf (_(" Return register: %s\n"),
9219 tic6x_unwind_regnames[word & 0xf]);
9220 }
9221 else
9222 printf (_(" [reserved (%d)]\n"), per_index);
9223 break;
9224
9225 default:
9226 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9227 filedata->file_header.e_machine);
9228 res = FALSE;
9229 }
9230
9231 /* Decode the descriptors. Not implemented. */
9232
9233 return res;
9234 }
9235
9236 static bfd_boolean
9237 dump_arm_unwind (Filedata * filedata,
9238 struct arm_unw_aux_info * aux,
9239 Elf_Internal_Shdr * exidx_sec)
9240 {
9241 struct arm_section exidx_arm_sec, extab_arm_sec;
9242 unsigned int i, exidx_len;
9243 unsigned long j, nfuns;
9244 bfd_boolean res = TRUE;
9245
9246 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
9247 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
9248 exidx_len = exidx_sec->sh_size / 8;
9249
9250 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
9251 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
9252 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
9253 aux->funtab[nfuns++] = aux->symtab[j];
9254 aux->nfuns = nfuns;
9255 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
9256
9257 for (i = 0; i < exidx_len; i++)
9258 {
9259 unsigned int exidx_fn, exidx_entry;
9260 struct absaddr fn_addr, entry_addr;
9261 bfd_vma fn;
9262
9263 fputc ('\n', stdout);
9264
9265 if (! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9266 8 * i, & exidx_fn, & fn_addr, NULL)
9267 || ! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9268 8 * i + 4, & exidx_entry, & entry_addr, NULL))
9269 {
9270 free (aux->funtab);
9271 arm_free_section (& exidx_arm_sec);
9272 arm_free_section (& extab_arm_sec);
9273 return FALSE;
9274 }
9275
9276 /* ARM EHABI, Section 5:
9277 An index table entry consists of 2 words.
9278 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9279 if (exidx_fn & 0x80000000)
9280 {
9281 warn (_("corrupt index table entry: %x\n"), exidx_fn);
9282 res = FALSE;
9283 }
9284
9285 fn = arm_expand_prel31 (filedata, exidx_fn, exidx_sec->sh_addr + 8 * i);
9286
9287 arm_print_vma_and_name (filedata, aux, fn, fn_addr);
9288 fputs (": ", stdout);
9289
9290 if (exidx_entry == 1)
9291 {
9292 print_vma (exidx_entry, PREFIX_HEX);
9293 fputs (" [cantunwind]\n", stdout);
9294 }
9295 else if (exidx_entry & 0x80000000)
9296 {
9297 print_vma (exidx_entry, PREFIX_HEX);
9298 fputc ('\n', stdout);
9299 decode_arm_unwind (filedata, aux, exidx_entry, 4, 0, NULL, NULL);
9300 }
9301 else
9302 {
9303 bfd_vma table, table_offset = 0;
9304 Elf_Internal_Shdr *table_sec;
9305
9306 fputs ("@", stdout);
9307 table = arm_expand_prel31 (filedata, exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
9308 print_vma (table, PREFIX_HEX);
9309 printf ("\n");
9310
9311 /* Locate the matching .ARM.extab. */
9312 if (entry_addr.section != SHN_UNDEF
9313 && entry_addr.section < filedata->file_header.e_shnum)
9314 {
9315 table_sec = filedata->section_headers + entry_addr.section;
9316 table_offset = entry_addr.offset;
9317 /* PR 18879 */
9318 if (table_offset > table_sec->sh_size
9319 || ((bfd_signed_vma) table_offset) < 0)
9320 {
9321 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9322 (unsigned long) table_offset,
9323 printable_section_name (filedata, table_sec));
9324 res = FALSE;
9325 continue;
9326 }
9327 }
9328 else
9329 {
9330 table_sec = find_section_by_address (filedata, table);
9331 if (table_sec != NULL)
9332 table_offset = table - table_sec->sh_addr;
9333 }
9334
9335 if (table_sec == NULL)
9336 {
9337 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9338 (unsigned long) table);
9339 res = FALSE;
9340 continue;
9341 }
9342
9343 if (! decode_arm_unwind (filedata, aux, 0, 0, table_offset, table_sec,
9344 &extab_arm_sec))
9345 res = FALSE;
9346 }
9347 }
9348
9349 printf ("\n");
9350
9351 free (aux->funtab);
9352 arm_free_section (&exidx_arm_sec);
9353 arm_free_section (&extab_arm_sec);
9354
9355 return res;
9356 }
9357
9358 /* Used for both ARM and C6X unwinding tables. */
9359
9360 static bfd_boolean
9361 arm_process_unwind (Filedata * filedata)
9362 {
9363 struct arm_unw_aux_info aux;
9364 Elf_Internal_Shdr *unwsec = NULL;
9365 Elf_Internal_Shdr *strsec;
9366 Elf_Internal_Shdr *sec;
9367 unsigned long i;
9368 unsigned int sec_type;
9369 bfd_boolean res = TRUE;
9370
9371 switch (filedata->file_header.e_machine)
9372 {
9373 case EM_ARM:
9374 sec_type = SHT_ARM_EXIDX;
9375 break;
9376
9377 case EM_TI_C6000:
9378 sec_type = SHT_C6000_UNWIND;
9379 break;
9380
9381 default:
9382 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9383 filedata->file_header.e_machine);
9384 return FALSE;
9385 }
9386
9387 if (filedata->string_table == NULL)
9388 return FALSE;
9389
9390 memset (& aux, 0, sizeof (aux));
9391 aux.filedata = filedata;
9392
9393 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9394 {
9395 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < filedata->file_header.e_shnum)
9396 {
9397 aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
9398
9399 strsec = filedata->section_headers + sec->sh_link;
9400
9401 /* PR binutils/17531 file: 011-12666-0.004. */
9402 if (aux.strtab != NULL)
9403 {
9404 error (_("Multiple string tables found in file.\n"));
9405 free (aux.strtab);
9406 res = FALSE;
9407 }
9408 aux.strtab = get_data (NULL, filedata, strsec->sh_offset,
9409 1, strsec->sh_size, _("string table"));
9410 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
9411 }
9412 else if (sec->sh_type == sec_type)
9413 unwsec = sec;
9414 }
9415
9416 if (unwsec == NULL)
9417 printf (_("\nThere are no unwind sections in this file.\n"));
9418 else
9419 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9420 {
9421 if (sec->sh_type == sec_type)
9422 {
9423 unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size);
9424 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9425 "contains %lu entry:\n",
9426 "\nUnwind section '%s' at offset 0x%lx "
9427 "contains %lu entries:\n",
9428 num_unwind),
9429 printable_section_name (filedata, sec),
9430 (unsigned long) sec->sh_offset,
9431 num_unwind);
9432
9433 if (! dump_arm_unwind (filedata, &aux, sec))
9434 res = FALSE;
9435 }
9436 }
9437
9438 if (aux.symtab)
9439 free (aux.symtab);
9440 if (aux.strtab)
9441 free ((char *) aux.strtab);
9442
9443 return res;
9444 }
9445
9446 static bfd_boolean
9447 process_unwind (Filedata * filedata)
9448 {
9449 struct unwind_handler
9450 {
9451 unsigned int machtype;
9452 bfd_boolean (* handler)(Filedata *);
9453 } handlers[] =
9454 {
9455 { EM_ARM, arm_process_unwind },
9456 { EM_IA_64, ia64_process_unwind },
9457 { EM_PARISC, hppa_process_unwind },
9458 { EM_TI_C6000, arm_process_unwind },
9459 { 0, NULL }
9460 };
9461 int i;
9462
9463 if (!do_unwind)
9464 return TRUE;
9465
9466 for (i = 0; handlers[i].handler != NULL; i++)
9467 if (filedata->file_header.e_machine == handlers[i].machtype)
9468 return handlers[i].handler (filedata);
9469
9470 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9471 get_machine_name (filedata->file_header.e_machine));
9472 return TRUE;
9473 }
9474
9475 static void
9476 dynamic_section_aarch64_val (Elf_Internal_Dyn * entry)
9477 {
9478 switch (entry->d_tag)
9479 {
9480 case DT_AARCH64_BTI_PLT:
9481 case DT_AARCH64_PAC_PLT:
9482 break;
9483 default:
9484 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9485 break;
9486 }
9487 putchar ('\n');
9488 }
9489
9490 static void
9491 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
9492 {
9493 switch (entry->d_tag)
9494 {
9495 case DT_MIPS_FLAGS:
9496 if (entry->d_un.d_val == 0)
9497 printf (_("NONE"));
9498 else
9499 {
9500 static const char * opts[] =
9501 {
9502 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9503 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9504 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9505 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9506 "RLD_ORDER_SAFE"
9507 };
9508 unsigned int cnt;
9509 bfd_boolean first = TRUE;
9510
9511 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9512 if (entry->d_un.d_val & (1 << cnt))
9513 {
9514 printf ("%s%s", first ? "" : " ", opts[cnt]);
9515 first = FALSE;
9516 }
9517 }
9518 break;
9519
9520 case DT_MIPS_IVERSION:
9521 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9522 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
9523 else
9524 {
9525 char buf[40];
9526 sprintf_vma (buf, entry->d_un.d_ptr);
9527 /* Note: coded this way so that there is a single string for translation. */
9528 printf (_("<corrupt: %s>"), buf);
9529 }
9530 break;
9531
9532 case DT_MIPS_TIME_STAMP:
9533 {
9534 char timebuf[128];
9535 struct tm * tmp;
9536 time_t atime = entry->d_un.d_val;
9537
9538 tmp = gmtime (&atime);
9539 /* PR 17531: file: 6accc532. */
9540 if (tmp == NULL)
9541 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9542 else
9543 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9544 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9545 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9546 printf (_("Time Stamp: %s"), timebuf);
9547 }
9548 break;
9549
9550 case DT_MIPS_RLD_VERSION:
9551 case DT_MIPS_LOCAL_GOTNO:
9552 case DT_MIPS_CONFLICTNO:
9553 case DT_MIPS_LIBLISTNO:
9554 case DT_MIPS_SYMTABNO:
9555 case DT_MIPS_UNREFEXTNO:
9556 case DT_MIPS_HIPAGENO:
9557 case DT_MIPS_DELTA_CLASS_NO:
9558 case DT_MIPS_DELTA_INSTANCE_NO:
9559 case DT_MIPS_DELTA_RELOC_NO:
9560 case DT_MIPS_DELTA_SYM_NO:
9561 case DT_MIPS_DELTA_CLASSSYM_NO:
9562 case DT_MIPS_COMPACT_SIZE:
9563 print_vma (entry->d_un.d_val, DEC);
9564 break;
9565
9566 case DT_MIPS_XHASH:
9567 dynamic_info_DT_MIPS_XHASH = entry->d_un.d_val;
9568 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9569 /* Falls through. */
9570
9571 default:
9572 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9573 }
9574 putchar ('\n');
9575 }
9576
9577 static void
9578 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9579 {
9580 switch (entry->d_tag)
9581 {
9582 case DT_HP_DLD_FLAGS:
9583 {
9584 static struct
9585 {
9586 long int bit;
9587 const char * str;
9588 }
9589 flags[] =
9590 {
9591 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9592 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9593 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9594 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9595 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9596 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9597 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9598 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9599 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9600 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9601 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9602 { DT_HP_GST, "HP_GST" },
9603 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9604 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9605 { DT_HP_NODELETE, "HP_NODELETE" },
9606 { DT_HP_GROUP, "HP_GROUP" },
9607 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9608 };
9609 bfd_boolean first = TRUE;
9610 size_t cnt;
9611 bfd_vma val = entry->d_un.d_val;
9612
9613 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9614 if (val & flags[cnt].bit)
9615 {
9616 if (! first)
9617 putchar (' ');
9618 fputs (flags[cnt].str, stdout);
9619 first = FALSE;
9620 val ^= flags[cnt].bit;
9621 }
9622
9623 if (val != 0 || first)
9624 {
9625 if (! first)
9626 putchar (' ');
9627 print_vma (val, HEX);
9628 }
9629 }
9630 break;
9631
9632 default:
9633 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9634 break;
9635 }
9636 putchar ('\n');
9637 }
9638
9639 #ifdef BFD64
9640
9641 /* VMS vs Unix time offset and factor. */
9642
9643 #define VMS_EPOCH_OFFSET 35067168000000000LL
9644 #define VMS_GRANULARITY_FACTOR 10000000
9645
9646 /* Display a VMS time in a human readable format. */
9647
9648 static void
9649 print_vms_time (bfd_int64_t vmstime)
9650 {
9651 struct tm *tm;
9652 time_t unxtime;
9653
9654 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9655 tm = gmtime (&unxtime);
9656 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9657 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9658 tm->tm_hour, tm->tm_min, tm->tm_sec);
9659 }
9660 #endif /* BFD64 */
9661
9662 static void
9663 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9664 {
9665 switch (entry->d_tag)
9666 {
9667 case DT_IA_64_PLT_RESERVE:
9668 /* First 3 slots reserved. */
9669 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9670 printf (" -- ");
9671 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9672 break;
9673
9674 case DT_IA_64_VMS_LINKTIME:
9675 #ifdef BFD64
9676 print_vms_time (entry->d_un.d_val);
9677 #endif
9678 break;
9679
9680 case DT_IA_64_VMS_LNKFLAGS:
9681 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9682 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9683 printf (" CALL_DEBUG");
9684 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9685 printf (" NOP0BUFS");
9686 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9687 printf (" P0IMAGE");
9688 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9689 printf (" MKTHREADS");
9690 if (entry->d_un.d_val & VMS_LF_UPCALLS)
9691 printf (" UPCALLS");
9692 if (entry->d_un.d_val & VMS_LF_IMGSTA)
9693 printf (" IMGSTA");
9694 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9695 printf (" INITIALIZE");
9696 if (entry->d_un.d_val & VMS_LF_MAIN)
9697 printf (" MAIN");
9698 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9699 printf (" EXE_INIT");
9700 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9701 printf (" TBK_IN_IMG");
9702 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9703 printf (" DBG_IN_IMG");
9704 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9705 printf (" TBK_IN_DSF");
9706 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9707 printf (" DBG_IN_DSF");
9708 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9709 printf (" SIGNATURES");
9710 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9711 printf (" REL_SEG_OFF");
9712 break;
9713
9714 default:
9715 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9716 break;
9717 }
9718 putchar ('\n');
9719 }
9720
9721 static bfd_boolean
9722 get_32bit_dynamic_section (Filedata * filedata)
9723 {
9724 Elf32_External_Dyn * edyn;
9725 Elf32_External_Dyn * ext;
9726 Elf_Internal_Dyn * entry;
9727
9728 edyn = (Elf32_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9729 dynamic_size, _("dynamic section"));
9730 if (!edyn)
9731 return FALSE;
9732
9733 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9734 might not have the luxury of section headers. Look for the DT_NULL
9735 terminator to determine the number of entries. */
9736 for (ext = edyn, dynamic_nent = 0;
9737 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9738 ext++)
9739 {
9740 dynamic_nent++;
9741 if (BYTE_GET (ext->d_tag) == DT_NULL)
9742 break;
9743 }
9744
9745 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9746 sizeof (* entry));
9747 if (dynamic_section == NULL)
9748 {
9749 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9750 (unsigned long) dynamic_nent);
9751 free (edyn);
9752 return FALSE;
9753 }
9754
9755 for (ext = edyn, entry = dynamic_section;
9756 entry < dynamic_section + dynamic_nent;
9757 ext++, entry++)
9758 {
9759 entry->d_tag = BYTE_GET (ext->d_tag);
9760 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9761 }
9762
9763 free (edyn);
9764
9765 return TRUE;
9766 }
9767
9768 static bfd_boolean
9769 get_64bit_dynamic_section (Filedata * filedata)
9770 {
9771 Elf64_External_Dyn * edyn;
9772 Elf64_External_Dyn * ext;
9773 Elf_Internal_Dyn * entry;
9774
9775 /* Read in the data. */
9776 edyn = (Elf64_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9777 dynamic_size, _("dynamic section"));
9778 if (!edyn)
9779 return FALSE;
9780
9781 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9782 might not have the luxury of section headers. Look for the DT_NULL
9783 terminator to determine the number of entries. */
9784 for (ext = edyn, dynamic_nent = 0;
9785 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9786 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9787 ext++)
9788 {
9789 dynamic_nent++;
9790 if (BYTE_GET (ext->d_tag) == DT_NULL)
9791 break;
9792 }
9793
9794 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9795 sizeof (* entry));
9796 if (dynamic_section == NULL)
9797 {
9798 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9799 (unsigned long) dynamic_nent);
9800 free (edyn);
9801 return FALSE;
9802 }
9803
9804 /* Convert from external to internal formats. */
9805 for (ext = edyn, entry = dynamic_section;
9806 entry < dynamic_section + dynamic_nent;
9807 ext++, entry++)
9808 {
9809 entry->d_tag = BYTE_GET (ext->d_tag);
9810 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9811 }
9812
9813 free (edyn);
9814
9815 return TRUE;
9816 }
9817
9818 static void
9819 print_dynamic_flags (bfd_vma flags)
9820 {
9821 bfd_boolean first = TRUE;
9822
9823 while (flags)
9824 {
9825 bfd_vma flag;
9826
9827 flag = flags & - flags;
9828 flags &= ~ flag;
9829
9830 if (first)
9831 first = FALSE;
9832 else
9833 putc (' ', stdout);
9834
9835 switch (flag)
9836 {
9837 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
9838 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
9839 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
9840 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
9841 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
9842 default: fputs (_("unknown"), stdout); break;
9843 }
9844 }
9845 puts ("");
9846 }
9847
9848 /* Parse and display the contents of the dynamic section. */
9849
9850 static bfd_boolean
9851 process_dynamic_section (Filedata * filedata)
9852 {
9853 Elf_Internal_Dyn * entry;
9854
9855 if (dynamic_size == 0)
9856 {
9857 if (do_dynamic)
9858 printf (_("\nThere is no dynamic section in this file.\n"));
9859
9860 return TRUE;
9861 }
9862
9863 if (is_32bit_elf)
9864 {
9865 if (! get_32bit_dynamic_section (filedata))
9866 return FALSE;
9867 }
9868 else
9869 {
9870 if (! get_64bit_dynamic_section (filedata))
9871 return FALSE;
9872 }
9873
9874 /* Find the appropriate symbol table. */
9875 if (dynamic_symbols == NULL)
9876 {
9877 for (entry = dynamic_section;
9878 entry < dynamic_section + dynamic_nent;
9879 ++entry)
9880 {
9881 Elf_Internal_Shdr section;
9882
9883 if (entry->d_tag != DT_SYMTAB)
9884 continue;
9885
9886 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9887
9888 /* Since we do not know how big the symbol table is,
9889 we default to reading in the entire file (!) and
9890 processing that. This is overkill, I know, but it
9891 should work. */
9892 section.sh_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9893 if ((bfd_size_type) section.sh_offset > filedata->file_size)
9894 {
9895 /* See PR 21379 for a reproducer. */
9896 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section.sh_offset);
9897 return FALSE;
9898 }
9899
9900 if (archive_file_offset != 0)
9901 section.sh_size = archive_file_size - section.sh_offset;
9902 else
9903 section.sh_size = filedata->file_size - section.sh_offset;
9904
9905 if (is_32bit_elf)
9906 section.sh_entsize = sizeof (Elf32_External_Sym);
9907 else
9908 section.sh_entsize = sizeof (Elf64_External_Sym);
9909 section.sh_name = filedata->string_table_length;
9910
9911 if (dynamic_symbols != NULL)
9912 {
9913 error (_("Multiple dynamic symbol table sections found\n"));
9914 free (dynamic_symbols);
9915 }
9916 dynamic_symbols = GET_ELF_SYMBOLS (filedata, &section, & num_dynamic_syms);
9917 if (num_dynamic_syms < 1)
9918 {
9919 error (_("Unable to determine the number of symbols to load\n"));
9920 continue;
9921 }
9922 }
9923 }
9924
9925 /* Similarly find a string table. */
9926 if (dynamic_strings == NULL)
9927 {
9928 for (entry = dynamic_section;
9929 entry < dynamic_section + dynamic_nent;
9930 ++entry)
9931 {
9932 unsigned long offset;
9933 long str_tab_len;
9934
9935 if (entry->d_tag != DT_STRTAB)
9936 continue;
9937
9938 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9939
9940 /* Since we do not know how big the string table is,
9941 we default to reading in the entire file (!) and
9942 processing that. This is overkill, I know, but it
9943 should work. */
9944
9945 offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9946
9947 if (archive_file_offset != 0)
9948 str_tab_len = archive_file_size - offset;
9949 else
9950 str_tab_len = filedata->file_size - offset;
9951
9952 if (str_tab_len < 1)
9953 {
9954 error
9955 (_("Unable to determine the length of the dynamic string table\n"));
9956 continue;
9957 }
9958
9959 if (dynamic_strings != NULL)
9960 {
9961 error (_("Multiple dynamic string tables found\n"));
9962 free (dynamic_strings);
9963 }
9964
9965 dynamic_strings = (char *) get_data (NULL, filedata, offset, 1,
9966 str_tab_len,
9967 _("dynamic string table"));
9968 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9969 }
9970 }
9971
9972 /* And find the syminfo section if available. */
9973 if (dynamic_syminfo == NULL)
9974 {
9975 unsigned long syminsz = 0;
9976
9977 for (entry = dynamic_section;
9978 entry < dynamic_section + dynamic_nent;
9979 ++entry)
9980 {
9981 if (entry->d_tag == DT_SYMINENT)
9982 {
9983 /* Note: these braces are necessary to avoid a syntax
9984 error from the SunOS4 C compiler. */
9985 /* PR binutils/17531: A corrupt file can trigger this test.
9986 So do not use an assert, instead generate an error message. */
9987 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9988 error (_("Bad value (%d) for SYMINENT entry\n"),
9989 (int) entry->d_un.d_val);
9990 }
9991 else if (entry->d_tag == DT_SYMINSZ)
9992 syminsz = entry->d_un.d_val;
9993 else if (entry->d_tag == DT_SYMINFO)
9994 dynamic_syminfo_offset = offset_from_vma (filedata, entry->d_un.d_val,
9995 syminsz);
9996 }
9997
9998 if (dynamic_syminfo_offset != 0 && syminsz != 0)
9999 {
10000 Elf_External_Syminfo * extsyminfo;
10001 Elf_External_Syminfo * extsym;
10002 Elf_Internal_Syminfo * syminfo;
10003
10004 /* There is a syminfo section. Read the data. */
10005 extsyminfo = (Elf_External_Syminfo *)
10006 get_data (NULL, filedata, dynamic_syminfo_offset, 1, syminsz,
10007 _("symbol information"));
10008 if (!extsyminfo)
10009 return FALSE;
10010
10011 if (dynamic_syminfo != NULL)
10012 {
10013 error (_("Multiple dynamic symbol information sections found\n"));
10014 free (dynamic_syminfo);
10015 }
10016 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
10017 if (dynamic_syminfo == NULL)
10018 {
10019 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
10020 (unsigned long) syminsz);
10021 return FALSE;
10022 }
10023
10024 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
10025 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
10026 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
10027 ++syminfo, ++extsym)
10028 {
10029 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
10030 syminfo->si_flags = BYTE_GET (extsym->si_flags);
10031 }
10032
10033 free (extsyminfo);
10034 }
10035 }
10036
10037 if (do_dynamic && dynamic_addr)
10038 printf (ngettext ("\nDynamic section at offset 0x%lx "
10039 "contains %lu entry:\n",
10040 "\nDynamic section at offset 0x%lx "
10041 "contains %lu entries:\n",
10042 dynamic_nent),
10043 dynamic_addr, (unsigned long) dynamic_nent);
10044 if (do_dynamic)
10045 printf (_(" Tag Type Name/Value\n"));
10046
10047 for (entry = dynamic_section;
10048 entry < dynamic_section + dynamic_nent;
10049 entry++)
10050 {
10051 if (do_dynamic)
10052 {
10053 const char * dtype;
10054
10055 putchar (' ');
10056 print_vma (entry->d_tag, FULL_HEX);
10057 dtype = get_dynamic_type (filedata, entry->d_tag);
10058 printf (" (%s)%*s", dtype,
10059 ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
10060 }
10061
10062 switch (entry->d_tag)
10063 {
10064 case DT_FLAGS:
10065 if (do_dynamic)
10066 print_dynamic_flags (entry->d_un.d_val);
10067 break;
10068
10069 case DT_AUXILIARY:
10070 case DT_FILTER:
10071 case DT_CONFIG:
10072 case DT_DEPAUDIT:
10073 case DT_AUDIT:
10074 if (do_dynamic)
10075 {
10076 switch (entry->d_tag)
10077 {
10078 case DT_AUXILIARY:
10079 printf (_("Auxiliary library"));
10080 break;
10081
10082 case DT_FILTER:
10083 printf (_("Filter library"));
10084 break;
10085
10086 case DT_CONFIG:
10087 printf (_("Configuration file"));
10088 break;
10089
10090 case DT_DEPAUDIT:
10091 printf (_("Dependency audit library"));
10092 break;
10093
10094 case DT_AUDIT:
10095 printf (_("Audit library"));
10096 break;
10097 }
10098
10099 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
10100 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
10101 else
10102 {
10103 printf (": ");
10104 print_vma (entry->d_un.d_val, PREFIX_HEX);
10105 putchar ('\n');
10106 }
10107 }
10108 break;
10109
10110 case DT_FEATURE:
10111 if (do_dynamic)
10112 {
10113 printf (_("Flags:"));
10114
10115 if (entry->d_un.d_val == 0)
10116 printf (_(" None\n"));
10117 else
10118 {
10119 unsigned long int val = entry->d_un.d_val;
10120
10121 if (val & DTF_1_PARINIT)
10122 {
10123 printf (" PARINIT");
10124 val ^= DTF_1_PARINIT;
10125 }
10126 if (val & DTF_1_CONFEXP)
10127 {
10128 printf (" CONFEXP");
10129 val ^= DTF_1_CONFEXP;
10130 }
10131 if (val != 0)
10132 printf (" %lx", val);
10133 puts ("");
10134 }
10135 }
10136 break;
10137
10138 case DT_POSFLAG_1:
10139 if (do_dynamic)
10140 {
10141 printf (_("Flags:"));
10142
10143 if (entry->d_un.d_val == 0)
10144 printf (_(" None\n"));
10145 else
10146 {
10147 unsigned long int val = entry->d_un.d_val;
10148
10149 if (val & DF_P1_LAZYLOAD)
10150 {
10151 printf (" LAZYLOAD");
10152 val ^= DF_P1_LAZYLOAD;
10153 }
10154 if (val & DF_P1_GROUPPERM)
10155 {
10156 printf (" GROUPPERM");
10157 val ^= DF_P1_GROUPPERM;
10158 }
10159 if (val != 0)
10160 printf (" %lx", val);
10161 puts ("");
10162 }
10163 }
10164 break;
10165
10166 case DT_FLAGS_1:
10167 if (do_dynamic)
10168 {
10169 printf (_("Flags:"));
10170 if (entry->d_un.d_val == 0)
10171 printf (_(" None\n"));
10172 else
10173 {
10174 unsigned long int val = entry->d_un.d_val;
10175
10176 if (val & DF_1_NOW)
10177 {
10178 printf (" NOW");
10179 val ^= DF_1_NOW;
10180 }
10181 if (val & DF_1_GLOBAL)
10182 {
10183 printf (" GLOBAL");
10184 val ^= DF_1_GLOBAL;
10185 }
10186 if (val & DF_1_GROUP)
10187 {
10188 printf (" GROUP");
10189 val ^= DF_1_GROUP;
10190 }
10191 if (val & DF_1_NODELETE)
10192 {
10193 printf (" NODELETE");
10194 val ^= DF_1_NODELETE;
10195 }
10196 if (val & DF_1_LOADFLTR)
10197 {
10198 printf (" LOADFLTR");
10199 val ^= DF_1_LOADFLTR;
10200 }
10201 if (val & DF_1_INITFIRST)
10202 {
10203 printf (" INITFIRST");
10204 val ^= DF_1_INITFIRST;
10205 }
10206 if (val & DF_1_NOOPEN)
10207 {
10208 printf (" NOOPEN");
10209 val ^= DF_1_NOOPEN;
10210 }
10211 if (val & DF_1_ORIGIN)
10212 {
10213 printf (" ORIGIN");
10214 val ^= DF_1_ORIGIN;
10215 }
10216 if (val & DF_1_DIRECT)
10217 {
10218 printf (" DIRECT");
10219 val ^= DF_1_DIRECT;
10220 }
10221 if (val & DF_1_TRANS)
10222 {
10223 printf (" TRANS");
10224 val ^= DF_1_TRANS;
10225 }
10226 if (val & DF_1_INTERPOSE)
10227 {
10228 printf (" INTERPOSE");
10229 val ^= DF_1_INTERPOSE;
10230 }
10231 if (val & DF_1_NODEFLIB)
10232 {
10233 printf (" NODEFLIB");
10234 val ^= DF_1_NODEFLIB;
10235 }
10236 if (val & DF_1_NODUMP)
10237 {
10238 printf (" NODUMP");
10239 val ^= DF_1_NODUMP;
10240 }
10241 if (val & DF_1_CONFALT)
10242 {
10243 printf (" CONFALT");
10244 val ^= DF_1_CONFALT;
10245 }
10246 if (val & DF_1_ENDFILTEE)
10247 {
10248 printf (" ENDFILTEE");
10249 val ^= DF_1_ENDFILTEE;
10250 }
10251 if (val & DF_1_DISPRELDNE)
10252 {
10253 printf (" DISPRELDNE");
10254 val ^= DF_1_DISPRELDNE;
10255 }
10256 if (val & DF_1_DISPRELPND)
10257 {
10258 printf (" DISPRELPND");
10259 val ^= DF_1_DISPRELPND;
10260 }
10261 if (val & DF_1_NODIRECT)
10262 {
10263 printf (" NODIRECT");
10264 val ^= DF_1_NODIRECT;
10265 }
10266 if (val & DF_1_IGNMULDEF)
10267 {
10268 printf (" IGNMULDEF");
10269 val ^= DF_1_IGNMULDEF;
10270 }
10271 if (val & DF_1_NOKSYMS)
10272 {
10273 printf (" NOKSYMS");
10274 val ^= DF_1_NOKSYMS;
10275 }
10276 if (val & DF_1_NOHDR)
10277 {
10278 printf (" NOHDR");
10279 val ^= DF_1_NOHDR;
10280 }
10281 if (val & DF_1_EDITED)
10282 {
10283 printf (" EDITED");
10284 val ^= DF_1_EDITED;
10285 }
10286 if (val & DF_1_NORELOC)
10287 {
10288 printf (" NORELOC");
10289 val ^= DF_1_NORELOC;
10290 }
10291 if (val & DF_1_SYMINTPOSE)
10292 {
10293 printf (" SYMINTPOSE");
10294 val ^= DF_1_SYMINTPOSE;
10295 }
10296 if (val & DF_1_GLOBAUDIT)
10297 {
10298 printf (" GLOBAUDIT");
10299 val ^= DF_1_GLOBAUDIT;
10300 }
10301 if (val & DF_1_SINGLETON)
10302 {
10303 printf (" SINGLETON");
10304 val ^= DF_1_SINGLETON;
10305 }
10306 if (val & DF_1_STUB)
10307 {
10308 printf (" STUB");
10309 val ^= DF_1_STUB;
10310 }
10311 if (val & DF_1_PIE)
10312 {
10313 printf (" PIE");
10314 val ^= DF_1_PIE;
10315 }
10316 if (val & DF_1_KMOD)
10317 {
10318 printf (" KMOD");
10319 val ^= DF_1_KMOD;
10320 }
10321 if (val & DF_1_WEAKFILTER)
10322 {
10323 printf (" WEAKFILTER");
10324 val ^= DF_1_WEAKFILTER;
10325 }
10326 if (val & DF_1_NOCOMMON)
10327 {
10328 printf (" NOCOMMON");
10329 val ^= DF_1_NOCOMMON;
10330 }
10331 if (val != 0)
10332 printf (" %lx", val);
10333 puts ("");
10334 }
10335 }
10336 break;
10337
10338 case DT_PLTREL:
10339 dynamic_info[entry->d_tag] = entry->d_un.d_val;
10340 if (do_dynamic)
10341 puts (get_dynamic_type (filedata, entry->d_un.d_val));
10342 break;
10343
10344 case DT_NULL :
10345 case DT_NEEDED :
10346 case DT_PLTGOT :
10347 case DT_HASH :
10348 case DT_STRTAB :
10349 case DT_SYMTAB :
10350 case DT_RELA :
10351 case DT_INIT :
10352 case DT_FINI :
10353 case DT_SONAME :
10354 case DT_RPATH :
10355 case DT_SYMBOLIC:
10356 case DT_REL :
10357 case DT_DEBUG :
10358 case DT_TEXTREL :
10359 case DT_JMPREL :
10360 case DT_RUNPATH :
10361 dynamic_info[entry->d_tag] = entry->d_un.d_val;
10362
10363 if (do_dynamic)
10364 {
10365 char * name;
10366
10367 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
10368 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10369 else
10370 name = NULL;
10371
10372 if (name)
10373 {
10374 switch (entry->d_tag)
10375 {
10376 case DT_NEEDED:
10377 printf (_("Shared library: [%s]"), name);
10378
10379 if (streq (name, program_interpreter))
10380 printf (_(" program interpreter"));
10381 break;
10382
10383 case DT_SONAME:
10384 printf (_("Library soname: [%s]"), name);
10385 break;
10386
10387 case DT_RPATH:
10388 printf (_("Library rpath: [%s]"), name);
10389 break;
10390
10391 case DT_RUNPATH:
10392 printf (_("Library runpath: [%s]"), name);
10393 break;
10394
10395 default:
10396 print_vma (entry->d_un.d_val, PREFIX_HEX);
10397 break;
10398 }
10399 }
10400 else
10401 print_vma (entry->d_un.d_val, PREFIX_HEX);
10402
10403 putchar ('\n');
10404 }
10405 break;
10406
10407 case DT_PLTRELSZ:
10408 case DT_RELASZ :
10409 case DT_STRSZ :
10410 case DT_RELSZ :
10411 case DT_RELAENT :
10412 case DT_SYMENT :
10413 case DT_RELENT :
10414 dynamic_info[entry->d_tag] = entry->d_un.d_val;
10415 /* Fall through. */
10416 case DT_PLTPADSZ:
10417 case DT_MOVEENT :
10418 case DT_MOVESZ :
10419 case DT_INIT_ARRAYSZ:
10420 case DT_FINI_ARRAYSZ:
10421 case DT_GNU_CONFLICTSZ:
10422 case DT_GNU_LIBLISTSZ:
10423 if (do_dynamic)
10424 {
10425 print_vma (entry->d_un.d_val, UNSIGNED);
10426 printf (_(" (bytes)\n"));
10427 }
10428 break;
10429
10430 case DT_VERDEFNUM:
10431 case DT_VERNEEDNUM:
10432 case DT_RELACOUNT:
10433 case DT_RELCOUNT:
10434 if (do_dynamic)
10435 {
10436 print_vma (entry->d_un.d_val, UNSIGNED);
10437 putchar ('\n');
10438 }
10439 break;
10440
10441 case DT_SYMINSZ:
10442 case DT_SYMINENT:
10443 case DT_SYMINFO:
10444 case DT_USED:
10445 case DT_INIT_ARRAY:
10446 case DT_FINI_ARRAY:
10447 if (do_dynamic)
10448 {
10449 if (entry->d_tag == DT_USED
10450 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
10451 {
10452 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10453
10454 if (*name)
10455 {
10456 printf (_("Not needed object: [%s]\n"), name);
10457 break;
10458 }
10459 }
10460
10461 print_vma (entry->d_un.d_val, PREFIX_HEX);
10462 putchar ('\n');
10463 }
10464 break;
10465
10466 case DT_BIND_NOW:
10467 /* The value of this entry is ignored. */
10468 if (do_dynamic)
10469 putchar ('\n');
10470 break;
10471
10472 case DT_GNU_PRELINKED:
10473 if (do_dynamic)
10474 {
10475 struct tm * tmp;
10476 time_t atime = entry->d_un.d_val;
10477
10478 tmp = gmtime (&atime);
10479 /* PR 17533 file: 041-1244816-0.004. */
10480 if (tmp == NULL)
10481 printf (_("<corrupt time val: %lx"),
10482 (unsigned long) atime);
10483 else
10484 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10485 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10486 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10487
10488 }
10489 break;
10490
10491 case DT_GNU_HASH:
10492 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10493 if (do_dynamic)
10494 {
10495 print_vma (entry->d_un.d_val, PREFIX_HEX);
10496 putchar ('\n');
10497 }
10498 break;
10499
10500 default:
10501 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
10502 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
10503 entry->d_un.d_val;
10504
10505 if (do_dynamic)
10506 {
10507 switch (filedata->file_header.e_machine)
10508 {
10509 case EM_AARCH64:
10510 dynamic_section_aarch64_val (entry);
10511 break;
10512 case EM_MIPS:
10513 case EM_MIPS_RS3_LE:
10514 dynamic_section_mips_val (entry);
10515 break;
10516 case EM_PARISC:
10517 dynamic_section_parisc_val (entry);
10518 break;
10519 case EM_IA_64:
10520 dynamic_section_ia64_val (entry);
10521 break;
10522 default:
10523 print_vma (entry->d_un.d_val, PREFIX_HEX);
10524 putchar ('\n');
10525 }
10526 }
10527 break;
10528 }
10529 }
10530
10531 return TRUE;
10532 }
10533
10534 static char *
10535 get_ver_flags (unsigned int flags)
10536 {
10537 static char buff[128];
10538
10539 buff[0] = 0;
10540
10541 if (flags == 0)
10542 return _("none");
10543
10544 if (flags & VER_FLG_BASE)
10545 strcat (buff, "BASE");
10546
10547 if (flags & VER_FLG_WEAK)
10548 {
10549 if (flags & VER_FLG_BASE)
10550 strcat (buff, " | ");
10551
10552 strcat (buff, "WEAK");
10553 }
10554
10555 if (flags & VER_FLG_INFO)
10556 {
10557 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10558 strcat (buff, " | ");
10559
10560 strcat (buff, "INFO");
10561 }
10562
10563 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10564 {
10565 if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10566 strcat (buff, " | ");
10567
10568 strcat (buff, _("<unknown>"));
10569 }
10570
10571 return buff;
10572 }
10573
10574 /* Display the contents of the version sections. */
10575
10576 static bfd_boolean
10577 process_version_sections (Filedata * filedata)
10578 {
10579 Elf_Internal_Shdr * section;
10580 unsigned i;
10581 bfd_boolean found = FALSE;
10582
10583 if (! do_version)
10584 return TRUE;
10585
10586 for (i = 0, section = filedata->section_headers;
10587 i < filedata->file_header.e_shnum;
10588 i++, section++)
10589 {
10590 switch (section->sh_type)
10591 {
10592 case SHT_GNU_verdef:
10593 {
10594 Elf_External_Verdef * edefs;
10595 unsigned long idx;
10596 unsigned long cnt;
10597 char * endbuf;
10598
10599 found = TRUE;
10600
10601 printf (ngettext ("\nVersion definition section '%s' "
10602 "contains %u entry:\n",
10603 "\nVersion definition section '%s' "
10604 "contains %u entries:\n",
10605 section->sh_info),
10606 printable_section_name (filedata, section),
10607 section->sh_info);
10608
10609 printf (_(" Addr: 0x"));
10610 printf_vma (section->sh_addr);
10611 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10612 (unsigned long) section->sh_offset, section->sh_link,
10613 printable_section_name_from_index (filedata, section->sh_link));
10614
10615 edefs = (Elf_External_Verdef *)
10616 get_data (NULL, filedata, section->sh_offset, 1,section->sh_size,
10617 _("version definition section"));
10618 if (!edefs)
10619 break;
10620 endbuf = (char *) edefs + section->sh_size;
10621
10622 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10623 {
10624 char * vstart;
10625 Elf_External_Verdef * edef;
10626 Elf_Internal_Verdef ent;
10627 Elf_External_Verdaux * eaux;
10628 Elf_Internal_Verdaux aux;
10629 unsigned long isum;
10630 int j;
10631
10632 vstart = ((char *) edefs) + idx;
10633 if (vstart + sizeof (*edef) > endbuf)
10634 break;
10635
10636 edef = (Elf_External_Verdef *) vstart;
10637
10638 ent.vd_version = BYTE_GET (edef->vd_version);
10639 ent.vd_flags = BYTE_GET (edef->vd_flags);
10640 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
10641 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
10642 ent.vd_hash = BYTE_GET (edef->vd_hash);
10643 ent.vd_aux = BYTE_GET (edef->vd_aux);
10644 ent.vd_next = BYTE_GET (edef->vd_next);
10645
10646 printf (_(" %#06lx: Rev: %d Flags: %s"),
10647 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10648
10649 printf (_(" Index: %d Cnt: %d "),
10650 ent.vd_ndx, ent.vd_cnt);
10651
10652 /* Check for overflow. */
10653 if (ent.vd_aux > (size_t) (endbuf - vstart))
10654 break;
10655
10656 vstart += ent.vd_aux;
10657
10658 if (vstart + sizeof (*eaux) > endbuf)
10659 break;
10660 eaux = (Elf_External_Verdaux *) vstart;
10661
10662 aux.vda_name = BYTE_GET (eaux->vda_name);
10663 aux.vda_next = BYTE_GET (eaux->vda_next);
10664
10665 if (VALID_DYNAMIC_NAME (aux.vda_name))
10666 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
10667 else
10668 printf (_("Name index: %ld\n"), aux.vda_name);
10669
10670 isum = idx + ent.vd_aux;
10671
10672 for (j = 1; j < ent.vd_cnt; j++)
10673 {
10674 if (aux.vda_next < sizeof (*eaux)
10675 && !(j == ent.vd_cnt - 1 && aux.vda_next == 0))
10676 {
10677 warn (_("Invalid vda_next field of %lx\n"),
10678 aux.vda_next);
10679 j = ent.vd_cnt;
10680 break;
10681 }
10682 /* Check for overflow. */
10683 if (aux.vda_next > (size_t) (endbuf - vstart))
10684 break;
10685
10686 isum += aux.vda_next;
10687 vstart += aux.vda_next;
10688
10689 if (vstart + sizeof (*eaux) > endbuf)
10690 break;
10691 eaux = (Elf_External_Verdaux *) vstart;
10692
10693 aux.vda_name = BYTE_GET (eaux->vda_name);
10694 aux.vda_next = BYTE_GET (eaux->vda_next);
10695
10696 if (VALID_DYNAMIC_NAME (aux.vda_name))
10697 printf (_(" %#06lx: Parent %d: %s\n"),
10698 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
10699 else
10700 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10701 isum, j, aux.vda_name);
10702 }
10703
10704 if (j < ent.vd_cnt)
10705 printf (_(" Version def aux past end of section\n"));
10706
10707 /* PR 17531:
10708 file: id:000001,src:000172+005151,op:splice,rep:2. */
10709 if (ent.vd_next < sizeof (*edef)
10710 && !(cnt == section->sh_info - 1 && ent.vd_next == 0))
10711 {
10712 warn (_("Invalid vd_next field of %lx\n"), ent.vd_next);
10713 cnt = section->sh_info;
10714 break;
10715 }
10716 if (ent.vd_next > (size_t) (endbuf - ((char *) edefs + idx)))
10717 break;
10718
10719 idx += ent.vd_next;
10720 }
10721
10722 if (cnt < section->sh_info)
10723 printf (_(" Version definition past end of section\n"));
10724
10725 free (edefs);
10726 }
10727 break;
10728
10729 case SHT_GNU_verneed:
10730 {
10731 Elf_External_Verneed * eneed;
10732 unsigned long idx;
10733 unsigned long cnt;
10734 char * endbuf;
10735
10736 found = TRUE;
10737
10738 printf (ngettext ("\nVersion needs section '%s' "
10739 "contains %u entry:\n",
10740 "\nVersion needs section '%s' "
10741 "contains %u entries:\n",
10742 section->sh_info),
10743 printable_section_name (filedata, section), section->sh_info);
10744
10745 printf (_(" Addr: 0x"));
10746 printf_vma (section->sh_addr);
10747 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10748 (unsigned long) section->sh_offset, section->sh_link,
10749 printable_section_name_from_index (filedata, section->sh_link));
10750
10751 eneed = (Elf_External_Verneed *) get_data (NULL, filedata,
10752 section->sh_offset, 1,
10753 section->sh_size,
10754 _("Version Needs section"));
10755 if (!eneed)
10756 break;
10757 endbuf = (char *) eneed + section->sh_size;
10758
10759 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10760 {
10761 Elf_External_Verneed * entry;
10762 Elf_Internal_Verneed ent;
10763 unsigned long isum;
10764 int j;
10765 char * vstart;
10766
10767 vstart = ((char *) eneed) + idx;
10768 if (vstart + sizeof (*entry) > endbuf)
10769 break;
10770
10771 entry = (Elf_External_Verneed *) vstart;
10772
10773 ent.vn_version = BYTE_GET (entry->vn_version);
10774 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
10775 ent.vn_file = BYTE_GET (entry->vn_file);
10776 ent.vn_aux = BYTE_GET (entry->vn_aux);
10777 ent.vn_next = BYTE_GET (entry->vn_next);
10778
10779 printf (_(" %#06lx: Version: %d"), idx, ent.vn_version);
10780
10781 if (VALID_DYNAMIC_NAME (ent.vn_file))
10782 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
10783 else
10784 printf (_(" File: %lx"), ent.vn_file);
10785
10786 printf (_(" Cnt: %d\n"), ent.vn_cnt);
10787
10788 /* Check for overflow. */
10789 if (ent.vn_aux > (size_t) (endbuf - vstart))
10790 break;
10791 vstart += ent.vn_aux;
10792
10793 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10794 {
10795 Elf_External_Vernaux * eaux;
10796 Elf_Internal_Vernaux aux;
10797
10798 if (vstart + sizeof (*eaux) > endbuf)
10799 break;
10800 eaux = (Elf_External_Vernaux *) vstart;
10801
10802 aux.vna_hash = BYTE_GET (eaux->vna_hash);
10803 aux.vna_flags = BYTE_GET (eaux->vna_flags);
10804 aux.vna_other = BYTE_GET (eaux->vna_other);
10805 aux.vna_name = BYTE_GET (eaux->vna_name);
10806 aux.vna_next = BYTE_GET (eaux->vna_next);
10807
10808 if (VALID_DYNAMIC_NAME (aux.vna_name))
10809 printf (_(" %#06lx: Name: %s"),
10810 isum, GET_DYNAMIC_NAME (aux.vna_name));
10811 else
10812 printf (_(" %#06lx: Name index: %lx"),
10813 isum, aux.vna_name);
10814
10815 printf (_(" Flags: %s Version: %d\n"),
10816 get_ver_flags (aux.vna_flags), aux.vna_other);
10817
10818 if (aux.vna_next < sizeof (*eaux)
10819 && !(j == ent.vn_cnt - 1 && aux.vna_next == 0))
10820 {
10821 warn (_("Invalid vna_next field of %lx\n"),
10822 aux.vna_next);
10823 j = ent.vn_cnt;
10824 break;
10825 }
10826 /* Check for overflow. */
10827 if (aux.vna_next > (size_t) (endbuf - vstart))
10828 break;
10829 isum += aux.vna_next;
10830 vstart += aux.vna_next;
10831 }
10832
10833 if (j < ent.vn_cnt)
10834 warn (_("Missing Version Needs auxillary information\n"));
10835
10836 if (ent.vn_next < sizeof (*entry)
10837 && !(cnt == section->sh_info - 1 && ent.vn_next == 0))
10838 {
10839 warn (_("Invalid vn_next field of %lx\n"), ent.vn_next);
10840 cnt = section->sh_info;
10841 break;
10842 }
10843 if (ent.vn_next > (size_t) (endbuf - ((char *) eneed + idx)))
10844 break;
10845 idx += ent.vn_next;
10846 }
10847
10848 if (cnt < section->sh_info)
10849 warn (_("Missing Version Needs information\n"));
10850
10851 free (eneed);
10852 }
10853 break;
10854
10855 case SHT_GNU_versym:
10856 {
10857 Elf_Internal_Shdr * link_section;
10858 size_t total;
10859 unsigned int cnt;
10860 unsigned char * edata;
10861 unsigned short * data;
10862 char * strtab;
10863 Elf_Internal_Sym * symbols;
10864 Elf_Internal_Shdr * string_sec;
10865 unsigned long num_syms;
10866 long off;
10867
10868 if (section->sh_link >= filedata->file_header.e_shnum)
10869 break;
10870
10871 link_section = filedata->section_headers + section->sh_link;
10872 total = section->sh_size / sizeof (Elf_External_Versym);
10873
10874 if (link_section->sh_link >= filedata->file_header.e_shnum)
10875 break;
10876
10877 found = TRUE;
10878
10879 symbols = GET_ELF_SYMBOLS (filedata, link_section, & num_syms);
10880 if (symbols == NULL)
10881 break;
10882
10883 string_sec = filedata->section_headers + link_section->sh_link;
10884
10885 strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
10886 string_sec->sh_size,
10887 _("version string table"));
10888 if (!strtab)
10889 {
10890 free (symbols);
10891 break;
10892 }
10893
10894 printf (ngettext ("\nVersion symbols section '%s' "
10895 "contains %lu entry:\n",
10896 "\nVersion symbols section '%s' "
10897 "contains %lu entries:\n",
10898 total),
10899 printable_section_name (filedata, section), (unsigned long) total);
10900
10901 printf (_(" Addr: 0x"));
10902 printf_vma (section->sh_addr);
10903 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10904 (unsigned long) section->sh_offset, section->sh_link,
10905 printable_section_name (filedata, link_section));
10906
10907 off = offset_from_vma (filedata,
10908 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10909 total * sizeof (short));
10910 edata = (unsigned char *) get_data (NULL, filedata, off, total,
10911 sizeof (short),
10912 _("version symbol data"));
10913 if (!edata)
10914 {
10915 free (strtab);
10916 free (symbols);
10917 break;
10918 }
10919
10920 data = (short unsigned int *) cmalloc (total, sizeof (short));
10921
10922 for (cnt = total; cnt --;)
10923 data[cnt] = byte_get (edata + cnt * sizeof (short),
10924 sizeof (short));
10925
10926 free (edata);
10927
10928 for (cnt = 0; cnt < total; cnt += 4)
10929 {
10930 int j, nn;
10931 char *name;
10932 char *invalid = _("*invalid*");
10933
10934 printf (" %03x:", cnt);
10935
10936 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10937 switch (data[cnt + j])
10938 {
10939 case 0:
10940 fputs (_(" 0 (*local*) "), stdout);
10941 break;
10942
10943 case 1:
10944 fputs (_(" 1 (*global*) "), stdout);
10945 break;
10946
10947 default:
10948 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10949 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10950
10951 /* If this index value is greater than the size of the symbols
10952 array, break to avoid an out-of-bounds read. */
10953 if ((unsigned long)(cnt + j) >= num_syms)
10954 {
10955 warn (_("invalid index into symbol array\n"));
10956 break;
10957 }
10958
10959 name = NULL;
10960 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10961 {
10962 Elf_Internal_Verneed ivn;
10963 unsigned long offset;
10964
10965 offset = offset_from_vma
10966 (filedata, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10967 sizeof (Elf_External_Verneed));
10968
10969 do
10970 {
10971 Elf_Internal_Vernaux ivna;
10972 Elf_External_Verneed evn;
10973 Elf_External_Vernaux evna;
10974 unsigned long a_off;
10975
10976 if (get_data (&evn, filedata, offset, sizeof (evn), 1,
10977 _("version need")) == NULL)
10978 break;
10979
10980 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10981 ivn.vn_next = BYTE_GET (evn.vn_next);
10982
10983 a_off = offset + ivn.vn_aux;
10984
10985 do
10986 {
10987 if (get_data (&evna, filedata, a_off, sizeof (evna),
10988 1, _("version need aux (2)")) == NULL)
10989 {
10990 ivna.vna_next = 0;
10991 ivna.vna_other = 0;
10992 }
10993 else
10994 {
10995 ivna.vna_next = BYTE_GET (evna.vna_next);
10996 ivna.vna_other = BYTE_GET (evna.vna_other);
10997 }
10998
10999 a_off += ivna.vna_next;
11000 }
11001 while (ivna.vna_other != data[cnt + j]
11002 && ivna.vna_next != 0);
11003
11004 if (ivna.vna_other == data[cnt + j])
11005 {
11006 ivna.vna_name = BYTE_GET (evna.vna_name);
11007
11008 if (ivna.vna_name >= string_sec->sh_size)
11009 name = invalid;
11010 else
11011 name = strtab + ivna.vna_name;
11012 break;
11013 }
11014
11015 offset += ivn.vn_next;
11016 }
11017 while (ivn.vn_next);
11018 }
11019
11020 if (data[cnt + j] != 0x8001
11021 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11022 {
11023 Elf_Internal_Verdef ivd;
11024 Elf_External_Verdef evd;
11025 unsigned long offset;
11026
11027 offset = offset_from_vma
11028 (filedata, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11029 sizeof evd);
11030
11031 do
11032 {
11033 if (get_data (&evd, filedata, offset, sizeof (evd), 1,
11034 _("version def")) == NULL)
11035 {
11036 ivd.vd_next = 0;
11037 /* PR 17531: file: 046-1082287-0.004. */
11038 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
11039 break;
11040 }
11041 else
11042 {
11043 ivd.vd_next = BYTE_GET (evd.vd_next);
11044 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11045 }
11046
11047 offset += ivd.vd_next;
11048 }
11049 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
11050 && ivd.vd_next != 0);
11051
11052 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
11053 {
11054 Elf_External_Verdaux evda;
11055 Elf_Internal_Verdaux ivda;
11056
11057 ivd.vd_aux = BYTE_GET (evd.vd_aux);
11058
11059 if (get_data (&evda, filedata,
11060 offset - ivd.vd_next + ivd.vd_aux,
11061 sizeof (evda), 1,
11062 _("version def aux")) == NULL)
11063 break;
11064
11065 ivda.vda_name = BYTE_GET (evda.vda_name);
11066
11067 if (ivda.vda_name >= string_sec->sh_size)
11068 name = invalid;
11069 else if (name != NULL && name != invalid)
11070 name = _("*both*");
11071 else
11072 name = strtab + ivda.vda_name;
11073 }
11074 }
11075 if (name != NULL)
11076 nn += printf ("(%s%-*s",
11077 name,
11078 12 - (int) strlen (name),
11079 ")");
11080
11081 if (nn < 18)
11082 printf ("%*c", 18 - nn, ' ');
11083 }
11084
11085 putchar ('\n');
11086 }
11087
11088 free (data);
11089 free (strtab);
11090 free (symbols);
11091 }
11092 break;
11093
11094 default:
11095 break;
11096 }
11097 }
11098
11099 if (! found)
11100 printf (_("\nNo version information found in this file.\n"));
11101
11102 return TRUE;
11103 }
11104
11105 static const char *
11106 get_symbol_binding (Filedata * filedata, unsigned int binding)
11107 {
11108 static char buff[32];
11109
11110 switch (binding)
11111 {
11112 case STB_LOCAL: return "LOCAL";
11113 case STB_GLOBAL: return "GLOBAL";
11114 case STB_WEAK: return "WEAK";
11115 default:
11116 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
11117 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
11118 binding);
11119 else if (binding >= STB_LOOS && binding <= STB_HIOS)
11120 {
11121 if (binding == STB_GNU_UNIQUE
11122 && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU)
11123 return "UNIQUE";
11124 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
11125 }
11126 else
11127 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
11128 return buff;
11129 }
11130 }
11131
11132 static const char *
11133 get_symbol_type (Filedata * filedata, unsigned int type)
11134 {
11135 static char buff[32];
11136
11137 switch (type)
11138 {
11139 case STT_NOTYPE: return "NOTYPE";
11140 case STT_OBJECT: return "OBJECT";
11141 case STT_FUNC: return "FUNC";
11142 case STT_SECTION: return "SECTION";
11143 case STT_FILE: return "FILE";
11144 case STT_COMMON: return "COMMON";
11145 case STT_TLS: return "TLS";
11146 case STT_RELC: return "RELC";
11147 case STT_SRELC: return "SRELC";
11148 default:
11149 if (type >= STT_LOPROC && type <= STT_HIPROC)
11150 {
11151 if (filedata->file_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
11152 return "THUMB_FUNC";
11153
11154 if (filedata->file_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
11155 return "REGISTER";
11156
11157 if (filedata->file_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
11158 return "PARISC_MILLI";
11159
11160 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
11161 }
11162 else if (type >= STT_LOOS && type <= STT_HIOS)
11163 {
11164 if (filedata->file_header.e_machine == EM_PARISC)
11165 {
11166 if (type == STT_HP_OPAQUE)
11167 return "HP_OPAQUE";
11168 if (type == STT_HP_STUB)
11169 return "HP_STUB";
11170 }
11171
11172 if (type == STT_GNU_IFUNC
11173 && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
11174 || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD))
11175 return "IFUNC";
11176
11177 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
11178 }
11179 else
11180 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
11181 return buff;
11182 }
11183 }
11184
11185 static const char *
11186 get_symbol_visibility (unsigned int visibility)
11187 {
11188 switch (visibility)
11189 {
11190 case STV_DEFAULT: return "DEFAULT";
11191 case STV_INTERNAL: return "INTERNAL";
11192 case STV_HIDDEN: return "HIDDEN";
11193 case STV_PROTECTED: return "PROTECTED";
11194 default:
11195 error (_("Unrecognized visibility value: %u"), visibility);
11196 return _("<unknown>");
11197 }
11198 }
11199
11200 static const char *
11201 get_alpha_symbol_other (unsigned int other)
11202 {
11203 switch (other)
11204 {
11205 case STO_ALPHA_NOPV: return "NOPV";
11206 case STO_ALPHA_STD_GPLOAD: return "STD GPLOAD";
11207 default:
11208 error (_("Unrecognized alpah specific other value: %u"), other);
11209 return _("<unknown>");
11210 }
11211 }
11212
11213 static const char *
11214 get_solaris_symbol_visibility (unsigned int visibility)
11215 {
11216 switch (visibility)
11217 {
11218 case 4: return "EXPORTED";
11219 case 5: return "SINGLETON";
11220 case 6: return "ELIMINATE";
11221 default: return get_symbol_visibility (visibility);
11222 }
11223 }
11224
11225 static const char *
11226 get_aarch64_symbol_other (unsigned int other)
11227 {
11228 static char buf[32];
11229
11230 if (other & STO_AARCH64_VARIANT_PCS)
11231 {
11232 other &= ~STO_AARCH64_VARIANT_PCS;
11233 if (other == 0)
11234 return "VARIANT_PCS";
11235 snprintf (buf, sizeof buf, "VARIANT_PCS | %x", other);
11236 return buf;
11237 }
11238 return NULL;
11239 }
11240
11241 static const char *
11242 get_mips_symbol_other (unsigned int other)
11243 {
11244 switch (other)
11245 {
11246 case STO_OPTIONAL: return "OPTIONAL";
11247 case STO_MIPS_PLT: return "MIPS PLT";
11248 case STO_MIPS_PIC: return "MIPS PIC";
11249 case STO_MICROMIPS: return "MICROMIPS";
11250 case STO_MICROMIPS | STO_MIPS_PIC: return "MICROMIPS, MIPS PIC";
11251 case STO_MIPS16: return "MIPS16";
11252 default: return NULL;
11253 }
11254 }
11255
11256 static const char *
11257 get_ia64_symbol_other (Filedata * filedata, unsigned int other)
11258 {
11259 if (is_ia64_vms (filedata))
11260 {
11261 static char res[32];
11262
11263 res[0] = 0;
11264
11265 /* Function types is for images and .STB files only. */
11266 switch (filedata->file_header.e_type)
11267 {
11268 case ET_DYN:
11269 case ET_EXEC:
11270 switch (VMS_ST_FUNC_TYPE (other))
11271 {
11272 case VMS_SFT_CODE_ADDR:
11273 strcat (res, " CA");
11274 break;
11275 case VMS_SFT_SYMV_IDX:
11276 strcat (res, " VEC");
11277 break;
11278 case VMS_SFT_FD:
11279 strcat (res, " FD");
11280 break;
11281 case VMS_SFT_RESERVE:
11282 strcat (res, " RSV");
11283 break;
11284 default:
11285 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11286 VMS_ST_FUNC_TYPE (other));
11287 strcat (res, " <unknown>");
11288 break;
11289 }
11290 break;
11291 default:
11292 break;
11293 }
11294 switch (VMS_ST_LINKAGE (other))
11295 {
11296 case VMS_STL_IGNORE:
11297 strcat (res, " IGN");
11298 break;
11299 case VMS_STL_RESERVE:
11300 strcat (res, " RSV");
11301 break;
11302 case VMS_STL_STD:
11303 strcat (res, " STD");
11304 break;
11305 case VMS_STL_LNK:
11306 strcat (res, " LNK");
11307 break;
11308 default:
11309 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11310 VMS_ST_LINKAGE (other));
11311 strcat (res, " <unknown>");
11312 break;
11313 }
11314
11315 if (res[0] != 0)
11316 return res + 1;
11317 else
11318 return res;
11319 }
11320 return NULL;
11321 }
11322
11323 static const char *
11324 get_ppc64_symbol_other (unsigned int other)
11325 {
11326 if ((other & ~STO_PPC64_LOCAL_MASK) != 0)
11327 return NULL;
11328
11329 other >>= STO_PPC64_LOCAL_BIT;
11330 if (other <= 6)
11331 {
11332 static char buf[32];
11333 if (other >= 2)
11334 other = ppc64_decode_local_entry (other);
11335 snprintf (buf, sizeof buf, _("<localentry>: %d"), other);
11336 return buf;
11337 }
11338 return NULL;
11339 }
11340
11341 static const char *
11342 get_symbol_other (Filedata * filedata, unsigned int other)
11343 {
11344 const char * result = NULL;
11345 static char buff [32];
11346
11347 if (other == 0)
11348 return "";
11349
11350 switch (filedata->file_header.e_machine)
11351 {
11352 case EM_ALPHA:
11353 result = get_alpha_symbol_other (other);
11354 break;
11355 case EM_AARCH64:
11356 result = get_aarch64_symbol_other (other);
11357 break;
11358 case EM_MIPS:
11359 result = get_mips_symbol_other (other);
11360 break;
11361 case EM_IA_64:
11362 result = get_ia64_symbol_other (filedata, other);
11363 break;
11364 case EM_PPC64:
11365 result = get_ppc64_symbol_other (other);
11366 break;
11367 default:
11368 result = NULL;
11369 break;
11370 }
11371
11372 if (result)
11373 return result;
11374
11375 snprintf (buff, sizeof buff, _("<other>: %x"), other);
11376 return buff;
11377 }
11378
11379 static const char *
11380 get_symbol_index_type (Filedata * filedata, unsigned int type)
11381 {
11382 static char buff[32];
11383
11384 switch (type)
11385 {
11386 case SHN_UNDEF: return "UND";
11387 case SHN_ABS: return "ABS";
11388 case SHN_COMMON: return "COM";
11389 default:
11390 if (type == SHN_IA_64_ANSI_COMMON
11391 && filedata->file_header.e_machine == EM_IA_64
11392 && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
11393 return "ANSI_COM";
11394 else if ((filedata->file_header.e_machine == EM_X86_64
11395 || filedata->file_header.e_machine == EM_L1OM
11396 || filedata->file_header.e_machine == EM_K1OM)
11397 && type == SHN_X86_64_LCOMMON)
11398 return "LARGE_COM";
11399 else if ((type == SHN_MIPS_SCOMMON
11400 && filedata->file_header.e_machine == EM_MIPS)
11401 || (type == SHN_TIC6X_SCOMMON
11402 && filedata->file_header.e_machine == EM_TI_C6000))
11403 return "SCOM";
11404 else if (type == SHN_MIPS_SUNDEFINED
11405 && filedata->file_header.e_machine == EM_MIPS)
11406 return "SUND";
11407 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
11408 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
11409 else if (type >= SHN_LOOS && type <= SHN_HIOS)
11410 sprintf (buff, "OS [0x%04x]", type & 0xffff);
11411 else if (type >= SHN_LORESERVE)
11412 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
11413 else if (type >= filedata->file_header.e_shnum)
11414 sprintf (buff, _("bad section index[%3d]"), type);
11415 else
11416 sprintf (buff, "%3d", type);
11417 break;
11418 }
11419
11420 return buff;
11421 }
11422
11423 static bfd_vma *
11424 get_dynamic_data (Filedata * filedata, bfd_size_type number, unsigned int ent_size)
11425 {
11426 unsigned char * e_data;
11427 bfd_vma * i_data;
11428
11429 /* If the size_t type is smaller than the bfd_size_type, eg because
11430 you are building a 32-bit tool on a 64-bit host, then make sure
11431 that when (number) is cast to (size_t) no information is lost. */
11432 if (sizeof (size_t) < sizeof (bfd_size_type)
11433 && (bfd_size_type) ((size_t) number) != number)
11434 {
11435 error (_("Size truncation prevents reading %s elements of size %u\n"),
11436 bfd_vmatoa ("u", number), ent_size);
11437 return NULL;
11438 }
11439
11440 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11441 attempting to allocate memory when the read is bound to fail. */
11442 if (ent_size * number > filedata->file_size)
11443 {
11444 error (_("Invalid number of dynamic entries: %s\n"),
11445 bfd_vmatoa ("u", number));
11446 return NULL;
11447 }
11448
11449 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
11450 if (e_data == NULL)
11451 {
11452 error (_("Out of memory reading %s dynamic entries\n"),
11453 bfd_vmatoa ("u", number));
11454 return NULL;
11455 }
11456
11457 if (fread (e_data, ent_size, (size_t) number, filedata->handle) != number)
11458 {
11459 error (_("Unable to read in %s bytes of dynamic data\n"),
11460 bfd_vmatoa ("u", number * ent_size));
11461 free (e_data);
11462 return NULL;
11463 }
11464
11465 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
11466 if (i_data == NULL)
11467 {
11468 error (_("Out of memory allocating space for %s dynamic entries\n"),
11469 bfd_vmatoa ("u", number));
11470 free (e_data);
11471 return NULL;
11472 }
11473
11474 while (number--)
11475 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
11476
11477 free (e_data);
11478
11479 return i_data;
11480 }
11481
11482 static void
11483 print_dynamic_symbol (Filedata * filedata, bfd_vma si, unsigned long hn)
11484 {
11485 Elf_Internal_Sym * psym;
11486 int n;
11487
11488 n = print_vma (si, DEC_5);
11489 if (n < 5)
11490 fputs (&" "[n], stdout);
11491 printf (" %3lu: ", hn);
11492
11493 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
11494 {
11495 printf (_("<No info available for dynamic symbol number %lu>\n"),
11496 (unsigned long) si);
11497 return;
11498 }
11499
11500 psym = dynamic_symbols + si;
11501 print_vma (psym->st_value, LONG_HEX);
11502 putchar (' ');
11503 print_vma (psym->st_size, DEC_5);
11504
11505 printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11506 printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11507
11508 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11509 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
11510 else
11511 {
11512 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11513
11514 printf (" %-7s", get_symbol_visibility (vis));
11515 /* Check to see if any other bits in the st_other field are set.
11516 Note - displaying this information disrupts the layout of the
11517 table being generated, but for the moment this case is very
11518 rare. */
11519 if (psym->st_other ^ vis)
11520 printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11521 }
11522
11523 printf (" %3.3s ", get_symbol_index_type (filedata, psym->st_shndx));
11524 if (VALID_DYNAMIC_NAME (psym->st_name))
11525 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11526 else
11527 printf (_(" <corrupt: %14ld>"), psym->st_name);
11528 putchar ('\n');
11529 }
11530
11531 static const char *
11532 get_symbol_version_string (Filedata * filedata,
11533 bfd_boolean is_dynsym,
11534 const char * strtab,
11535 unsigned long int strtab_size,
11536 unsigned int si,
11537 Elf_Internal_Sym * psym,
11538 enum versioned_symbol_info * sym_info,
11539 unsigned short * vna_other)
11540 {
11541 unsigned char data[2];
11542 unsigned short vers_data;
11543 unsigned long offset;
11544 unsigned short max_vd_ndx;
11545
11546 if (!is_dynsym
11547 || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11548 return NULL;
11549
11550 offset = offset_from_vma (filedata, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11551 sizeof data + si * sizeof (vers_data));
11552
11553 if (get_data (&data, filedata, offset + si * sizeof (vers_data),
11554 sizeof (data), 1, _("version data")) == NULL)
11555 return NULL;
11556
11557 vers_data = byte_get (data, 2);
11558
11559 if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data == 0)
11560 return NULL;
11561
11562 *sym_info = (vers_data & VERSYM_HIDDEN) != 0 ? symbol_hidden : symbol_public;
11563 max_vd_ndx = 0;
11564
11565 /* Usually we'd only see verdef for defined symbols, and verneed for
11566 undefined symbols. However, symbols defined by the linker in
11567 .dynbss for variables copied from a shared library in order to
11568 avoid text relocations are defined yet have verneed. We could
11569 use a heuristic to detect the special case, for example, check
11570 for verneed first on symbols defined in SHT_NOBITS sections, but
11571 it is simpler and more reliable to just look for both verdef and
11572 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11573
11574 if (psym->st_shndx != SHN_UNDEF
11575 && vers_data != 0x8001
11576 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11577 {
11578 Elf_Internal_Verdef ivd;
11579 Elf_Internal_Verdaux ivda;
11580 Elf_External_Verdaux evda;
11581 unsigned long off;
11582
11583 off = offset_from_vma (filedata,
11584 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11585 sizeof (Elf_External_Verdef));
11586
11587 do
11588 {
11589 Elf_External_Verdef evd;
11590
11591 if (get_data (&evd, filedata, off, sizeof (evd), 1,
11592 _("version def")) == NULL)
11593 {
11594 ivd.vd_ndx = 0;
11595 ivd.vd_aux = 0;
11596 ivd.vd_next = 0;
11597 ivd.vd_flags = 0;
11598 }
11599 else
11600 {
11601 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11602 ivd.vd_aux = BYTE_GET (evd.vd_aux);
11603 ivd.vd_next = BYTE_GET (evd.vd_next);
11604 ivd.vd_flags = BYTE_GET (evd.vd_flags);
11605 }
11606
11607 if ((ivd.vd_ndx & VERSYM_VERSION) > max_vd_ndx)
11608 max_vd_ndx = ivd.vd_ndx & VERSYM_VERSION;
11609
11610 off += ivd.vd_next;
11611 }
11612 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11613
11614 if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11615 {
11616 if (ivd.vd_ndx == 1 && ivd.vd_flags == VER_FLG_BASE)
11617 return NULL;
11618
11619 off -= ivd.vd_next;
11620 off += ivd.vd_aux;
11621
11622 if (get_data (&evda, filedata, off, sizeof (evda), 1,
11623 _("version def aux")) != NULL)
11624 {
11625 ivda.vda_name = BYTE_GET (evda.vda_name);
11626
11627 if (psym->st_name != ivda.vda_name)
11628 return (ivda.vda_name < strtab_size
11629 ? strtab + ivda.vda_name : _("<corrupt>"));
11630 }
11631 }
11632 }
11633
11634 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11635 {
11636 Elf_External_Verneed evn;
11637 Elf_Internal_Verneed ivn;
11638 Elf_Internal_Vernaux ivna;
11639
11640 offset = offset_from_vma (filedata,
11641 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11642 sizeof evn);
11643 do
11644 {
11645 unsigned long vna_off;
11646
11647 if (get_data (&evn, filedata, offset, sizeof (evn), 1,
11648 _("version need")) == NULL)
11649 {
11650 ivna.vna_next = 0;
11651 ivna.vna_other = 0;
11652 ivna.vna_name = 0;
11653 break;
11654 }
11655
11656 ivn.vn_aux = BYTE_GET (evn.vn_aux);
11657 ivn.vn_next = BYTE_GET (evn.vn_next);
11658
11659 vna_off = offset + ivn.vn_aux;
11660
11661 do
11662 {
11663 Elf_External_Vernaux evna;
11664
11665 if (get_data (&evna, filedata, vna_off, sizeof (evna), 1,
11666 _("version need aux (3)")) == NULL)
11667 {
11668 ivna.vna_next = 0;
11669 ivna.vna_other = 0;
11670 ivna.vna_name = 0;
11671 }
11672 else
11673 {
11674 ivna.vna_other = BYTE_GET (evna.vna_other);
11675 ivna.vna_next = BYTE_GET (evna.vna_next);
11676 ivna.vna_name = BYTE_GET (evna.vna_name);
11677 }
11678
11679 vna_off += ivna.vna_next;
11680 }
11681 while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11682
11683 if (ivna.vna_other == vers_data)
11684 break;
11685
11686 offset += ivn.vn_next;
11687 }
11688 while (ivn.vn_next != 0);
11689
11690 if (ivna.vna_other == vers_data)
11691 {
11692 *sym_info = symbol_undefined;
11693 *vna_other = ivna.vna_other;
11694 return (ivna.vna_name < strtab_size
11695 ? strtab + ivna.vna_name : _("<corrupt>"));
11696 }
11697 else if ((max_vd_ndx || (vers_data & VERSYM_VERSION) != 1)
11698 && (vers_data & VERSYM_VERSION) > max_vd_ndx)
11699 return _("<corrupt>");
11700 }
11701 return NULL;
11702 }
11703
11704 /* Dump the symbol table. */
11705 static bfd_boolean
11706 process_symbol_table (Filedata * filedata)
11707 {
11708 Elf_Internal_Shdr * section;
11709 bfd_size_type nbuckets = 0;
11710 bfd_size_type nchains = 0;
11711 bfd_vma * buckets = NULL;
11712 bfd_vma * chains = NULL;
11713 bfd_vma ngnubuckets = 0;
11714 bfd_vma * gnubuckets = NULL;
11715 bfd_vma * gnuchains = NULL;
11716 bfd_vma * mipsxlat = NULL;
11717 bfd_vma gnusymidx = 0;
11718 bfd_size_type ngnuchains = 0;
11719
11720 if (!do_syms && !do_dyn_syms && !do_histogram)
11721 return TRUE;
11722
11723 if (dynamic_info[DT_HASH]
11724 && (do_histogram
11725 || (do_using_dynamic
11726 && !do_dyn_syms
11727 && dynamic_strings != NULL)))
11728 {
11729 unsigned char nb[8];
11730 unsigned char nc[8];
11731 unsigned int hash_ent_size = 4;
11732
11733 if ((filedata->file_header.e_machine == EM_ALPHA
11734 || filedata->file_header.e_machine == EM_S390
11735 || filedata->file_header.e_machine == EM_S390_OLD)
11736 && filedata->file_header.e_ident[EI_CLASS] == ELFCLASS64)
11737 hash_ent_size = 8;
11738
11739 if (fseek (filedata->handle,
11740 (archive_file_offset
11741 + offset_from_vma (filedata, dynamic_info[DT_HASH],
11742 sizeof nb + sizeof nc)),
11743 SEEK_SET))
11744 {
11745 error (_("Unable to seek to start of dynamic information\n"));
11746 goto no_hash;
11747 }
11748
11749 if (fread (nb, hash_ent_size, 1, filedata->handle) != 1)
11750 {
11751 error (_("Failed to read in number of buckets\n"));
11752 goto no_hash;
11753 }
11754
11755 if (fread (nc, hash_ent_size, 1, filedata->handle) != 1)
11756 {
11757 error (_("Failed to read in number of chains\n"));
11758 goto no_hash;
11759 }
11760
11761 nbuckets = byte_get (nb, hash_ent_size);
11762 nchains = byte_get (nc, hash_ent_size);
11763
11764 buckets = get_dynamic_data (filedata, nbuckets, hash_ent_size);
11765 chains = get_dynamic_data (filedata, nchains, hash_ent_size);
11766
11767 no_hash:
11768 if (buckets == NULL || chains == NULL)
11769 {
11770 if (do_using_dynamic)
11771 return FALSE;
11772 free (buckets);
11773 free (chains);
11774 buckets = NULL;
11775 chains = NULL;
11776 nbuckets = 0;
11777 nchains = 0;
11778 }
11779 }
11780
11781 if (dynamic_info_DT_GNU_HASH
11782 && (do_histogram
11783 || (do_using_dynamic
11784 && !do_dyn_syms
11785 && dynamic_strings != NULL)))
11786 {
11787 unsigned char nb[16];
11788 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11789 bfd_vma buckets_vma;
11790
11791 if (fseek (filedata->handle,
11792 (archive_file_offset
11793 + offset_from_vma (filedata, dynamic_info_DT_GNU_HASH,
11794 sizeof nb)),
11795 SEEK_SET))
11796 {
11797 error (_("Unable to seek to start of dynamic information\n"));
11798 goto no_gnu_hash;
11799 }
11800
11801 if (fread (nb, 16, 1, filedata->handle) != 1)
11802 {
11803 error (_("Failed to read in number of buckets\n"));
11804 goto no_gnu_hash;
11805 }
11806
11807 ngnubuckets = byte_get (nb, 4);
11808 gnusymidx = byte_get (nb + 4, 4);
11809 bitmaskwords = byte_get (nb + 8, 4);
11810 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11811 if (is_32bit_elf)
11812 buckets_vma += bitmaskwords * 4;
11813 else
11814 buckets_vma += bitmaskwords * 8;
11815
11816 if (fseek (filedata->handle,
11817 (archive_file_offset
11818 + offset_from_vma (filedata, buckets_vma, 4)),
11819 SEEK_SET))
11820 {
11821 error (_("Unable to seek to start of dynamic information\n"));
11822 goto no_gnu_hash;
11823 }
11824
11825 gnubuckets = get_dynamic_data (filedata, ngnubuckets, 4);
11826
11827 if (gnubuckets == NULL)
11828 goto no_gnu_hash;
11829
11830 for (i = 0; i < ngnubuckets; i++)
11831 if (gnubuckets[i] != 0)
11832 {
11833 if (gnubuckets[i] < gnusymidx)
11834 return FALSE;
11835
11836 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11837 maxchain = gnubuckets[i];
11838 }
11839
11840 if (maxchain == 0xffffffff)
11841 goto no_gnu_hash;
11842
11843 maxchain -= gnusymidx;
11844
11845 if (fseek (filedata->handle,
11846 (archive_file_offset
11847 + offset_from_vma (filedata, buckets_vma
11848 + 4 * (ngnubuckets + maxchain), 4)),
11849 SEEK_SET))
11850 {
11851 error (_("Unable to seek to start of dynamic information\n"));
11852 goto no_gnu_hash;
11853 }
11854
11855 do
11856 {
11857 if (fread (nb, 4, 1, filedata->handle) != 1)
11858 {
11859 error (_("Failed to determine last chain length\n"));
11860 goto no_gnu_hash;
11861 }
11862
11863 if (maxchain + 1 == 0)
11864 goto no_gnu_hash;
11865
11866 ++maxchain;
11867 }
11868 while ((byte_get (nb, 4) & 1) == 0);
11869
11870 if (fseek (filedata->handle,
11871 (archive_file_offset
11872 + offset_from_vma (filedata, buckets_vma + 4 * ngnubuckets, 4)),
11873 SEEK_SET))
11874 {
11875 error (_("Unable to seek to start of dynamic information\n"));
11876 goto no_gnu_hash;
11877 }
11878
11879 gnuchains = get_dynamic_data (filedata, maxchain, 4);
11880 ngnuchains = maxchain;
11881
11882 if (gnuchains == NULL)
11883 goto no_gnu_hash;
11884
11885 if (dynamic_info_DT_MIPS_XHASH)
11886 {
11887 if (fseek (filedata->handle,
11888 (archive_file_offset
11889 + offset_from_vma (filedata, (buckets_vma
11890 + 4 * (ngnubuckets
11891 + maxchain)), 4)),
11892 SEEK_SET))
11893 {
11894 error (_("Unable to seek to start of dynamic information\n"));
11895 goto no_gnu_hash;
11896 }
11897
11898 mipsxlat = get_dynamic_data (filedata, maxchain, 4);
11899 }
11900
11901 no_gnu_hash:
11902 if (dynamic_info_DT_MIPS_XHASH && mipsxlat == NULL)
11903 {
11904 free (gnuchains);
11905 gnuchains = NULL;
11906 }
11907 if (gnuchains == NULL)
11908 {
11909 free (gnubuckets);
11910 gnubuckets = NULL;
11911 ngnubuckets = 0;
11912 if (do_using_dynamic)
11913 return FALSE;
11914 }
11915 }
11916
11917 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11918 && do_syms
11919 && do_using_dynamic
11920 && dynamic_strings != NULL
11921 && dynamic_symbols != NULL)
11922 {
11923 unsigned long hn;
11924
11925 if (dynamic_info[DT_HASH])
11926 {
11927 bfd_vma si;
11928 char *visited;
11929
11930 printf (_("\nSymbol table for image:\n"));
11931 if (is_32bit_elf)
11932 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11933 else
11934 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11935
11936 visited = xcmalloc (nchains, 1);
11937 memset (visited, 0, nchains);
11938 for (hn = 0; hn < nbuckets; hn++)
11939 {
11940 for (si = buckets[hn]; si > 0; si = chains[si])
11941 {
11942 print_dynamic_symbol (filedata, si, hn);
11943 if (si >= nchains || visited[si])
11944 {
11945 error (_("histogram chain is corrupt\n"));
11946 break;
11947 }
11948 visited[si] = 1;
11949 }
11950 }
11951 free (visited);
11952 }
11953
11954 if (dynamic_info_DT_GNU_HASH)
11955 {
11956 printf (_("\nSymbol table of `%s' for image:\n"),
11957 GNU_HASH_SECTION_NAME);
11958 if (is_32bit_elf)
11959 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11960 else
11961 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11962
11963 for (hn = 0; hn < ngnubuckets; ++hn)
11964 if (gnubuckets[hn] != 0)
11965 {
11966 bfd_vma si = gnubuckets[hn];
11967 bfd_vma off = si - gnusymidx;
11968
11969 do
11970 {
11971 if (dynamic_info_DT_MIPS_XHASH)
11972 print_dynamic_symbol (filedata, mipsxlat[off], hn);
11973 else
11974 print_dynamic_symbol (filedata, si, hn);
11975 si++;
11976 }
11977 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11978 }
11979 }
11980 }
11981 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11982 && filedata->section_headers != NULL)
11983 {
11984 unsigned int i;
11985
11986 for (i = 0, section = filedata->section_headers;
11987 i < filedata->file_header.e_shnum;
11988 i++, section++)
11989 {
11990 unsigned int si;
11991 char * strtab = NULL;
11992 unsigned long int strtab_size = 0;
11993 Elf_Internal_Sym * symtab;
11994 Elf_Internal_Sym * psym;
11995 unsigned long num_syms;
11996
11997 if ((section->sh_type != SHT_SYMTAB
11998 && section->sh_type != SHT_DYNSYM)
11999 || (!do_syms
12000 && section->sh_type == SHT_SYMTAB))
12001 continue;
12002
12003 if (section->sh_entsize == 0)
12004 {
12005 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
12006 printable_section_name (filedata, section));
12007 continue;
12008 }
12009
12010 num_syms = section->sh_size / section->sh_entsize;
12011 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
12012 "\nSymbol table '%s' contains %lu entries:\n",
12013 num_syms),
12014 printable_section_name (filedata, section),
12015 num_syms);
12016
12017 if (is_32bit_elf)
12018 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12019 else
12020 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12021
12022 symtab = GET_ELF_SYMBOLS (filedata, section, & num_syms);
12023 if (symtab == NULL)
12024 continue;
12025
12026 if (section->sh_link == filedata->file_header.e_shstrndx)
12027 {
12028 strtab = filedata->string_table;
12029 strtab_size = filedata->string_table_length;
12030 }
12031 else if (section->sh_link < filedata->file_header.e_shnum)
12032 {
12033 Elf_Internal_Shdr * string_sec;
12034
12035 string_sec = filedata->section_headers + section->sh_link;
12036
12037 strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset,
12038 1, string_sec->sh_size,
12039 _("string table"));
12040 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
12041 }
12042
12043 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
12044 {
12045 const char *version_string;
12046 enum versioned_symbol_info sym_info;
12047 unsigned short vna_other;
12048
12049 printf ("%6d: ", si);
12050 print_vma (psym->st_value, LONG_HEX);
12051 putchar (' ');
12052 print_vma (psym->st_size, DEC_5);
12053 printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
12054 printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
12055 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
12056 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
12057 else
12058 {
12059 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
12060
12061 printf (" %-7s", get_symbol_visibility (vis));
12062 /* Check to see if any other bits in the st_other field are set.
12063 Note - displaying this information disrupts the layout of the
12064 table being generated, but for the moment this case is very rare. */
12065 if (psym->st_other ^ vis)
12066 printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
12067 }
12068 printf (" %4s ", get_symbol_index_type (filedata, psym->st_shndx));
12069 print_symbol (25, psym->st_name < strtab_size
12070 ? strtab + psym->st_name : _("<corrupt>"));
12071
12072 version_string
12073 = get_symbol_version_string (filedata,
12074 section->sh_type == SHT_DYNSYM,
12075 strtab, strtab_size, si,
12076 psym, &sym_info, &vna_other);
12077 if (version_string)
12078 {
12079 if (sym_info == symbol_undefined)
12080 printf ("@%s (%d)", version_string, vna_other);
12081 else
12082 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
12083 version_string);
12084 }
12085
12086 putchar ('\n');
12087
12088 if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
12089 && si >= section->sh_info
12090 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12091 && filedata->file_header.e_machine != EM_MIPS
12092 /* Solaris binaries have been found to violate this requirement as
12093 well. Not sure if this is a bug or an ABI requirement. */
12094 && filedata->file_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
12095 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
12096 si, printable_section_name (filedata, section), section->sh_info);
12097 }
12098
12099 free (symtab);
12100 if (strtab != filedata->string_table)
12101 free (strtab);
12102 }
12103 }
12104 else if (do_syms)
12105 printf
12106 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12107
12108 if (do_histogram && buckets != NULL)
12109 {
12110 unsigned long * lengths;
12111 unsigned long * counts;
12112 unsigned long hn;
12113 bfd_vma si;
12114 unsigned long maxlength = 0;
12115 unsigned long nzero_counts = 0;
12116 unsigned long nsyms = 0;
12117 char *visited;
12118
12119 printf (ngettext ("\nHistogram for bucket list length "
12120 "(total of %lu bucket):\n",
12121 "\nHistogram for bucket list length "
12122 "(total of %lu buckets):\n",
12123 (unsigned long) nbuckets),
12124 (unsigned long) nbuckets);
12125
12126 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
12127 if (lengths == NULL)
12128 {
12129 error (_("Out of memory allocating space for histogram buckets\n"));
12130 return FALSE;
12131 }
12132 visited = xcmalloc (nchains, 1);
12133 memset (visited, 0, nchains);
12134
12135 printf (_(" Length Number %% of total Coverage\n"));
12136 for (hn = 0; hn < nbuckets; ++hn)
12137 {
12138 for (si = buckets[hn]; si > 0; si = chains[si])
12139 {
12140 ++nsyms;
12141 if (maxlength < ++lengths[hn])
12142 ++maxlength;
12143 if (si >= nchains || visited[si])
12144 {
12145 error (_("histogram chain is corrupt\n"));
12146 break;
12147 }
12148 visited[si] = 1;
12149 }
12150 }
12151 free (visited);
12152
12153 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
12154 if (counts == NULL)
12155 {
12156 free (lengths);
12157 error (_("Out of memory allocating space for histogram counts\n"));
12158 return FALSE;
12159 }
12160
12161 for (hn = 0; hn < nbuckets; ++hn)
12162 ++counts[lengths[hn]];
12163
12164 if (nbuckets > 0)
12165 {
12166 unsigned long i;
12167 printf (" 0 %-10lu (%5.1f%%)\n",
12168 counts[0], (counts[0] * 100.0) / nbuckets);
12169 for (i = 1; i <= maxlength; ++i)
12170 {
12171 nzero_counts += counts[i] * i;
12172 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12173 i, counts[i], (counts[i] * 100.0) / nbuckets,
12174 (nzero_counts * 100.0) / nsyms);
12175 }
12176 }
12177
12178 free (counts);
12179 free (lengths);
12180 }
12181
12182 if (buckets != NULL)
12183 {
12184 free (buckets);
12185 free (chains);
12186 }
12187
12188 if (do_histogram && gnubuckets != NULL)
12189 {
12190 unsigned long * lengths;
12191 unsigned long * counts;
12192 unsigned long hn;
12193 unsigned long maxlength = 0;
12194 unsigned long nzero_counts = 0;
12195 unsigned long nsyms = 0;
12196
12197 printf (ngettext ("\nHistogram for `%s' bucket list length "
12198 "(total of %lu bucket):\n",
12199 "\nHistogram for `%s' bucket list length "
12200 "(total of %lu buckets):\n",
12201 (unsigned long) ngnubuckets),
12202 GNU_HASH_SECTION_NAME,
12203 (unsigned long) ngnubuckets);
12204
12205 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
12206 if (lengths == NULL)
12207 {
12208 error (_("Out of memory allocating space for gnu histogram buckets\n"));
12209 return FALSE;
12210 }
12211
12212 printf (_(" Length Number %% of total Coverage\n"));
12213
12214 for (hn = 0; hn < ngnubuckets; ++hn)
12215 if (gnubuckets[hn] != 0)
12216 {
12217 bfd_vma off, length = 1;
12218
12219 for (off = gnubuckets[hn] - gnusymidx;
12220 /* PR 17531 file: 010-77222-0.004. */
12221 off < ngnuchains && (gnuchains[off] & 1) == 0;
12222 ++off)
12223 ++length;
12224 lengths[hn] = length;
12225 if (length > maxlength)
12226 maxlength = length;
12227 nsyms += length;
12228 }
12229
12230 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
12231 if (counts == NULL)
12232 {
12233 free (lengths);
12234 error (_("Out of memory allocating space for gnu histogram counts\n"));
12235 return FALSE;
12236 }
12237
12238 for (hn = 0; hn < ngnubuckets; ++hn)
12239 ++counts[lengths[hn]];
12240
12241 if (ngnubuckets > 0)
12242 {
12243 unsigned long j;
12244 printf (" 0 %-10lu (%5.1f%%)\n",
12245 counts[0], (counts[0] * 100.0) / ngnubuckets);
12246 for (j = 1; j <= maxlength; ++j)
12247 {
12248 nzero_counts += counts[j] * j;
12249 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12250 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
12251 (nzero_counts * 100.0) / nsyms);
12252 }
12253 }
12254
12255 free (counts);
12256 free (lengths);
12257 free (gnubuckets);
12258 free (gnuchains);
12259 free (mipsxlat);
12260 }
12261
12262 return TRUE;
12263 }
12264
12265 static bfd_boolean
12266 process_syminfo (Filedata * filedata ATTRIBUTE_UNUSED)
12267 {
12268 unsigned int i;
12269
12270 if (dynamic_syminfo == NULL
12271 || !do_dynamic)
12272 /* No syminfo, this is ok. */
12273 return TRUE;
12274
12275 /* There better should be a dynamic symbol section. */
12276 if (dynamic_symbols == NULL || dynamic_strings == NULL)
12277 return FALSE;
12278
12279 if (dynamic_addr)
12280 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12281 "contains %d entry:\n",
12282 "\nDynamic info segment at offset 0x%lx "
12283 "contains %d entries:\n",
12284 dynamic_syminfo_nent),
12285 dynamic_syminfo_offset, dynamic_syminfo_nent);
12286
12287 printf (_(" Num: Name BoundTo Flags\n"));
12288 for (i = 0; i < dynamic_syminfo_nent; ++i)
12289 {
12290 unsigned short int flags = dynamic_syminfo[i].si_flags;
12291
12292 printf ("%4d: ", i);
12293 if (i >= num_dynamic_syms)
12294 printf (_("<corrupt index>"));
12295 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
12296 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
12297 else
12298 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
12299 putchar (' ');
12300
12301 switch (dynamic_syminfo[i].si_boundto)
12302 {
12303 case SYMINFO_BT_SELF:
12304 fputs ("SELF ", stdout);
12305 break;
12306 case SYMINFO_BT_PARENT:
12307 fputs ("PARENT ", stdout);
12308 break;
12309 default:
12310 if (dynamic_syminfo[i].si_boundto > 0
12311 && dynamic_syminfo[i].si_boundto < dynamic_nent
12312 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
12313 {
12314 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
12315 putchar (' ' );
12316 }
12317 else
12318 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
12319 break;
12320 }
12321
12322 if (flags & SYMINFO_FLG_DIRECT)
12323 printf (" DIRECT");
12324 if (flags & SYMINFO_FLG_PASSTHRU)
12325 printf (" PASSTHRU");
12326 if (flags & SYMINFO_FLG_COPY)
12327 printf (" COPY");
12328 if (flags & SYMINFO_FLG_LAZYLOAD)
12329 printf (" LAZYLOAD");
12330
12331 puts ("");
12332 }
12333
12334 return TRUE;
12335 }
12336
12337 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
12338 is contained by the region START .. END. The types of ADDR, START
12339 and END should all be the same. Note both ADDR + NELEM and END
12340 point to just beyond the end of the regions that are being tested. */
12341 #define IN_RANGE(START,END,ADDR,NELEM) \
12342 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
12343
12344 /* Check to see if the given reloc needs to be handled in a target specific
12345 manner. If so then process the reloc and return TRUE otherwise return
12346 FALSE.
12347
12348 If called with reloc == NULL, then this is a signal that reloc processing
12349 for the current section has finished, and any saved state should be
12350 discarded. */
12351
12352 static bfd_boolean
12353 target_specific_reloc_handling (Filedata * filedata,
12354 Elf_Internal_Rela * reloc,
12355 unsigned char * start,
12356 unsigned char * end,
12357 Elf_Internal_Sym * symtab,
12358 unsigned long num_syms)
12359 {
12360 unsigned int reloc_type = 0;
12361 unsigned long sym_index = 0;
12362
12363 if (reloc)
12364 {
12365 reloc_type = get_reloc_type (filedata, reloc->r_info);
12366 sym_index = get_reloc_symindex (reloc->r_info);
12367 }
12368
12369 switch (filedata->file_header.e_machine)
12370 {
12371 case EM_MSP430:
12372 case EM_MSP430_OLD:
12373 {
12374 static Elf_Internal_Sym * saved_sym = NULL;
12375
12376 if (reloc == NULL)
12377 {
12378 saved_sym = NULL;
12379 return TRUE;
12380 }
12381
12382 switch (reloc_type)
12383 {
12384 case 10: /* R_MSP430_SYM_DIFF */
12385 if (uses_msp430x_relocs (filedata))
12386 break;
12387 /* Fall through. */
12388 case 21: /* R_MSP430X_SYM_DIFF */
12389 /* PR 21139. */
12390 if (sym_index >= num_syms)
12391 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12392 sym_index);
12393 else
12394 saved_sym = symtab + sym_index;
12395 return TRUE;
12396
12397 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12398 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12399 goto handle_sym_diff;
12400
12401 case 5: /* R_MSP430_16_BYTE */
12402 case 9: /* R_MSP430_8 */
12403 if (uses_msp430x_relocs (filedata))
12404 break;
12405 goto handle_sym_diff;
12406
12407 case 2: /* R_MSP430_ABS16 */
12408 case 15: /* R_MSP430X_ABS16 */
12409 if (! uses_msp430x_relocs (filedata))
12410 break;
12411 goto handle_sym_diff;
12412
12413 handle_sym_diff:
12414 if (saved_sym != NULL)
12415 {
12416 int reloc_size = reloc_type == 1 ? 4 : 2;
12417 bfd_vma value;
12418
12419 if (sym_index >= num_syms)
12420 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12421 sym_index);
12422 else
12423 {
12424 value = reloc->r_addend + (symtab[sym_index].st_value
12425 - saved_sym->st_value);
12426
12427 if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12428 byte_put (start + reloc->r_offset, value, reloc_size);
12429 else
12430 /* PR 21137 */
12431 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12432 (long) reloc->r_offset);
12433 }
12434
12435 saved_sym = NULL;
12436 return TRUE;
12437 }
12438 break;
12439
12440 default:
12441 if (saved_sym != NULL)
12442 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12443 break;
12444 }
12445 break;
12446 }
12447
12448 case EM_MN10300:
12449 case EM_CYGNUS_MN10300:
12450 {
12451 static Elf_Internal_Sym * saved_sym = NULL;
12452
12453 if (reloc == NULL)
12454 {
12455 saved_sym = NULL;
12456 return TRUE;
12457 }
12458
12459 switch (reloc_type)
12460 {
12461 case 34: /* R_MN10300_ALIGN */
12462 return TRUE;
12463 case 33: /* R_MN10300_SYM_DIFF */
12464 if (sym_index >= num_syms)
12465 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12466 sym_index);
12467 else
12468 saved_sym = symtab + sym_index;
12469 return TRUE;
12470
12471 case 1: /* R_MN10300_32 */
12472 case 2: /* R_MN10300_16 */
12473 if (saved_sym != NULL)
12474 {
12475 int reloc_size = reloc_type == 1 ? 4 : 2;
12476 bfd_vma value;
12477
12478 if (sym_index >= num_syms)
12479 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12480 sym_index);
12481 else
12482 {
12483 value = reloc->r_addend + (symtab[sym_index].st_value
12484 - saved_sym->st_value);
12485
12486 if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12487 byte_put (start + reloc->r_offset, value, reloc_size);
12488 else
12489 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12490 (long) reloc->r_offset);
12491 }
12492
12493 saved_sym = NULL;
12494 return TRUE;
12495 }
12496 break;
12497 default:
12498 if (saved_sym != NULL)
12499 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12500 break;
12501 }
12502 break;
12503 }
12504
12505 case EM_RL78:
12506 {
12507 static bfd_vma saved_sym1 = 0;
12508 static bfd_vma saved_sym2 = 0;
12509 static bfd_vma value;
12510
12511 if (reloc == NULL)
12512 {
12513 saved_sym1 = saved_sym2 = 0;
12514 return TRUE;
12515 }
12516
12517 switch (reloc_type)
12518 {
12519 case 0x80: /* R_RL78_SYM. */
12520 saved_sym1 = saved_sym2;
12521 if (sym_index >= num_syms)
12522 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12523 sym_index);
12524 else
12525 {
12526 saved_sym2 = symtab[sym_index].st_value;
12527 saved_sym2 += reloc->r_addend;
12528 }
12529 return TRUE;
12530
12531 case 0x83: /* R_RL78_OPsub. */
12532 value = saved_sym1 - saved_sym2;
12533 saved_sym2 = saved_sym1 = 0;
12534 return TRUE;
12535 break;
12536
12537 case 0x41: /* R_RL78_ABS32. */
12538 if (IN_RANGE (start, end, start + reloc->r_offset, 4))
12539 byte_put (start + reloc->r_offset, value, 4);
12540 else
12541 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12542 (long) reloc->r_offset);
12543 value = 0;
12544 return TRUE;
12545
12546 case 0x43: /* R_RL78_ABS16. */
12547 if (IN_RANGE (start, end, start + reloc->r_offset, 2))
12548 byte_put (start + reloc->r_offset, value, 2);
12549 else
12550 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12551 (long) reloc->r_offset);
12552 value = 0;
12553 return TRUE;
12554
12555 default:
12556 break;
12557 }
12558 break;
12559 }
12560 }
12561
12562 return FALSE;
12563 }
12564
12565 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12566 DWARF debug sections. This is a target specific test. Note - we do not
12567 go through the whole including-target-headers-multiple-times route, (as
12568 we have already done with <elf/h8.h>) because this would become very
12569 messy and even then this function would have to contain target specific
12570 information (the names of the relocs instead of their numeric values).
12571 FIXME: This is not the correct way to solve this problem. The proper way
12572 is to have target specific reloc sizing and typing functions created by
12573 the reloc-macros.h header, in the same way that it already creates the
12574 reloc naming functions. */
12575
12576 static bfd_boolean
12577 is_32bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12578 {
12579 /* Please keep this table alpha-sorted for ease of visual lookup. */
12580 switch (filedata->file_header.e_machine)
12581 {
12582 case EM_386:
12583 case EM_IAMCU:
12584 return reloc_type == 1; /* R_386_32. */
12585 case EM_68K:
12586 return reloc_type == 1; /* R_68K_32. */
12587 case EM_860:
12588 return reloc_type == 1; /* R_860_32. */
12589 case EM_960:
12590 return reloc_type == 2; /* R_960_32. */
12591 case EM_AARCH64:
12592 return (reloc_type == 258
12593 || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12594 case EM_BPF:
12595 return reloc_type == 11; /* R_BPF_DATA_32 */
12596 case EM_ADAPTEVA_EPIPHANY:
12597 return reloc_type == 3;
12598 case EM_ALPHA:
12599 return reloc_type == 1; /* R_ALPHA_REFLONG. */
12600 case EM_ARC:
12601 return reloc_type == 1; /* R_ARC_32. */
12602 case EM_ARC_COMPACT:
12603 case EM_ARC_COMPACT2:
12604 return reloc_type == 4; /* R_ARC_32. */
12605 case EM_ARM:
12606 return reloc_type == 2; /* R_ARM_ABS32 */
12607 case EM_AVR_OLD:
12608 case EM_AVR:
12609 return reloc_type == 1;
12610 case EM_BLACKFIN:
12611 return reloc_type == 0x12; /* R_byte4_data. */
12612 case EM_CRIS:
12613 return reloc_type == 3; /* R_CRIS_32. */
12614 case EM_CR16:
12615 return reloc_type == 3; /* R_CR16_NUM32. */
12616 case EM_CRX:
12617 return reloc_type == 15; /* R_CRX_NUM32. */
12618 case EM_CSKY:
12619 return reloc_type == 1; /* R_CKCORE_ADDR32. */
12620 case EM_CYGNUS_FRV:
12621 return reloc_type == 1;
12622 case EM_CYGNUS_D10V:
12623 case EM_D10V:
12624 return reloc_type == 6; /* R_D10V_32. */
12625 case EM_CYGNUS_D30V:
12626 case EM_D30V:
12627 return reloc_type == 12; /* R_D30V_32_NORMAL. */
12628 case EM_DLX:
12629 return reloc_type == 3; /* R_DLX_RELOC_32. */
12630 case EM_CYGNUS_FR30:
12631 case EM_FR30:
12632 return reloc_type == 3; /* R_FR30_32. */
12633 case EM_FT32:
12634 return reloc_type == 1; /* R_FT32_32. */
12635 case EM_H8S:
12636 case EM_H8_300:
12637 case EM_H8_300H:
12638 return reloc_type == 1; /* R_H8_DIR32. */
12639 case EM_IA_64:
12640 return (reloc_type == 0x64 /* R_IA64_SECREL32MSB. */
12641 || reloc_type == 0x65 /* R_IA64_SECREL32LSB. */
12642 || reloc_type == 0x24 /* R_IA64_DIR32MSB. */
12643 || reloc_type == 0x25 /* R_IA64_DIR32LSB. */);
12644 case EM_IP2K_OLD:
12645 case EM_IP2K:
12646 return reloc_type == 2; /* R_IP2K_32. */
12647 case EM_IQ2000:
12648 return reloc_type == 2; /* R_IQ2000_32. */
12649 case EM_LATTICEMICO32:
12650 return reloc_type == 3; /* R_LM32_32. */
12651 case EM_M32C_OLD:
12652 case EM_M32C:
12653 return reloc_type == 3; /* R_M32C_32. */
12654 case EM_M32R:
12655 return reloc_type == 34; /* R_M32R_32_RELA. */
12656 case EM_68HC11:
12657 case EM_68HC12:
12658 return reloc_type == 6; /* R_M68HC11_32. */
12659 case EM_S12Z:
12660 return reloc_type == 7 || /* R_S12Z_EXT32 */
12661 reloc_type == 6; /* R_S12Z_CW32. */
12662 case EM_MCORE:
12663 return reloc_type == 1; /* R_MCORE_ADDR32. */
12664 case EM_CYGNUS_MEP:
12665 return reloc_type == 4; /* R_MEP_32. */
12666 case EM_METAG:
12667 return reloc_type == 2; /* R_METAG_ADDR32. */
12668 case EM_MICROBLAZE:
12669 return reloc_type == 1; /* R_MICROBLAZE_32. */
12670 case EM_MIPS:
12671 return reloc_type == 2; /* R_MIPS_32. */
12672 case EM_MMIX:
12673 return reloc_type == 4; /* R_MMIX_32. */
12674 case EM_CYGNUS_MN10200:
12675 case EM_MN10200:
12676 return reloc_type == 1; /* R_MN10200_32. */
12677 case EM_CYGNUS_MN10300:
12678 case EM_MN10300:
12679 return reloc_type == 1; /* R_MN10300_32. */
12680 case EM_MOXIE:
12681 return reloc_type == 1; /* R_MOXIE_32. */
12682 case EM_MSP430_OLD:
12683 case EM_MSP430:
12684 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12685 case EM_MT:
12686 return reloc_type == 2; /* R_MT_32. */
12687 case EM_NDS32:
12688 return reloc_type == 20; /* R_NDS32_RELA. */
12689 case EM_ALTERA_NIOS2:
12690 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
12691 case EM_NIOS32:
12692 return reloc_type == 1; /* R_NIOS_32. */
12693 case EM_OR1K:
12694 return reloc_type == 1; /* R_OR1K_32. */
12695 case EM_PARISC:
12696 return (reloc_type == 1 /* R_PARISC_DIR32. */
12697 || reloc_type == 2 /* R_PARISC_DIR21L. */
12698 || reloc_type == 41); /* R_PARISC_SECREL32. */
12699 case EM_PJ:
12700 case EM_PJ_OLD:
12701 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
12702 case EM_PPC64:
12703 return reloc_type == 1; /* R_PPC64_ADDR32. */
12704 case EM_PPC:
12705 return reloc_type == 1; /* R_PPC_ADDR32. */
12706 case EM_TI_PRU:
12707 return reloc_type == 11; /* R_PRU_BFD_RELOC_32. */
12708 case EM_RISCV:
12709 return reloc_type == 1; /* R_RISCV_32. */
12710 case EM_RL78:
12711 return reloc_type == 1; /* R_RL78_DIR32. */
12712 case EM_RX:
12713 return reloc_type == 1; /* R_RX_DIR32. */
12714 case EM_S370:
12715 return reloc_type == 1; /* R_I370_ADDR31. */
12716 case EM_S390_OLD:
12717 case EM_S390:
12718 return reloc_type == 4; /* R_S390_32. */
12719 case EM_SCORE:
12720 return reloc_type == 8; /* R_SCORE_ABS32. */
12721 case EM_SH:
12722 return reloc_type == 1; /* R_SH_DIR32. */
12723 case EM_SPARC32PLUS:
12724 case EM_SPARCV9:
12725 case EM_SPARC:
12726 return reloc_type == 3 /* R_SPARC_32. */
12727 || reloc_type == 23; /* R_SPARC_UA32. */
12728 case EM_SPU:
12729 return reloc_type == 6; /* R_SPU_ADDR32 */
12730 case EM_TI_C6000:
12731 return reloc_type == 1; /* R_C6000_ABS32. */
12732 case EM_TILEGX:
12733 return reloc_type == 2; /* R_TILEGX_32. */
12734 case EM_TILEPRO:
12735 return reloc_type == 1; /* R_TILEPRO_32. */
12736 case EM_CYGNUS_V850:
12737 case EM_V850:
12738 return reloc_type == 6; /* R_V850_ABS32. */
12739 case EM_V800:
12740 return reloc_type == 0x33; /* R_V810_WORD. */
12741 case EM_VAX:
12742 return reloc_type == 1; /* R_VAX_32. */
12743 case EM_VISIUM:
12744 return reloc_type == 3; /* R_VISIUM_32. */
12745 case EM_WEBASSEMBLY:
12746 return reloc_type == 1; /* R_WASM32_32. */
12747 case EM_X86_64:
12748 case EM_L1OM:
12749 case EM_K1OM:
12750 return reloc_type == 10; /* R_X86_64_32. */
12751 case EM_XC16X:
12752 case EM_C166:
12753 return reloc_type == 3; /* R_XC16C_ABS_32. */
12754 case EM_XGATE:
12755 return reloc_type == 4; /* R_XGATE_32. */
12756 case EM_XSTORMY16:
12757 return reloc_type == 1; /* R_XSTROMY16_32. */
12758 case EM_XTENSA_OLD:
12759 case EM_XTENSA:
12760 return reloc_type == 1; /* R_XTENSA_32. */
12761 default:
12762 {
12763 static unsigned int prev_warn = 0;
12764
12765 /* Avoid repeating the same warning multiple times. */
12766 if (prev_warn != filedata->file_header.e_machine)
12767 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12768 filedata->file_header.e_machine);
12769 prev_warn = filedata->file_header.e_machine;
12770 return FALSE;
12771 }
12772 }
12773 }
12774
12775 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12776 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12777
12778 static bfd_boolean
12779 is_32bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12780 {
12781 switch (filedata->file_header.e_machine)
12782 /* Please keep this table alpha-sorted for ease of visual lookup. */
12783 {
12784 case EM_386:
12785 case EM_IAMCU:
12786 return reloc_type == 2; /* R_386_PC32. */
12787 case EM_68K:
12788 return reloc_type == 4; /* R_68K_PC32. */
12789 case EM_AARCH64:
12790 return reloc_type == 261; /* R_AARCH64_PREL32 */
12791 case EM_ADAPTEVA_EPIPHANY:
12792 return reloc_type == 6;
12793 case EM_ALPHA:
12794 return reloc_type == 10; /* R_ALPHA_SREL32. */
12795 case EM_ARC_COMPACT:
12796 case EM_ARC_COMPACT2:
12797 return reloc_type == 49; /* R_ARC_32_PCREL. */
12798 case EM_ARM:
12799 return reloc_type == 3; /* R_ARM_REL32 */
12800 case EM_AVR_OLD:
12801 case EM_AVR:
12802 return reloc_type == 36; /* R_AVR_32_PCREL. */
12803 case EM_MICROBLAZE:
12804 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
12805 case EM_OR1K:
12806 return reloc_type == 9; /* R_OR1K_32_PCREL. */
12807 case EM_PARISC:
12808 return reloc_type == 9; /* R_PARISC_PCREL32. */
12809 case EM_PPC:
12810 return reloc_type == 26; /* R_PPC_REL32. */
12811 case EM_PPC64:
12812 return reloc_type == 26; /* R_PPC64_REL32. */
12813 case EM_RISCV:
12814 return reloc_type == 57; /* R_RISCV_32_PCREL. */
12815 case EM_S390_OLD:
12816 case EM_S390:
12817 return reloc_type == 5; /* R_390_PC32. */
12818 case EM_SH:
12819 return reloc_type == 2; /* R_SH_REL32. */
12820 case EM_SPARC32PLUS:
12821 case EM_SPARCV9:
12822 case EM_SPARC:
12823 return reloc_type == 6; /* R_SPARC_DISP32. */
12824 case EM_SPU:
12825 return reloc_type == 13; /* R_SPU_REL32. */
12826 case EM_TILEGX:
12827 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
12828 case EM_TILEPRO:
12829 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
12830 case EM_VISIUM:
12831 return reloc_type == 6; /* R_VISIUM_32_PCREL */
12832 case EM_X86_64:
12833 case EM_L1OM:
12834 case EM_K1OM:
12835 return reloc_type == 2; /* R_X86_64_PC32. */
12836 case EM_VAX:
12837 return reloc_type == 4; /* R_VAX_PCREL32. */
12838 case EM_XTENSA_OLD:
12839 case EM_XTENSA:
12840 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
12841 default:
12842 /* Do not abort or issue an error message here. Not all targets use
12843 pc-relative 32-bit relocs in their DWARF debug information and we
12844 have already tested for target coverage in is_32bit_abs_reloc. A
12845 more helpful warning message will be generated by apply_relocations
12846 anyway, so just return. */
12847 return FALSE;
12848 }
12849 }
12850
12851 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12852 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12853
12854 static bfd_boolean
12855 is_64bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12856 {
12857 switch (filedata->file_header.e_machine)
12858 {
12859 case EM_AARCH64:
12860 return reloc_type == 257; /* R_AARCH64_ABS64. */
12861 case EM_ALPHA:
12862 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
12863 case EM_IA_64:
12864 return (reloc_type == 0x26 /* R_IA64_DIR64MSB. */
12865 || reloc_type == 0x27 /* R_IA64_DIR64LSB. */);
12866 case EM_PARISC:
12867 return reloc_type == 80; /* R_PARISC_DIR64. */
12868 case EM_PPC64:
12869 return reloc_type == 38; /* R_PPC64_ADDR64. */
12870 case EM_RISCV:
12871 return reloc_type == 2; /* R_RISCV_64. */
12872 case EM_SPARC32PLUS:
12873 case EM_SPARCV9:
12874 case EM_SPARC:
12875 return reloc_type == 32 /* R_SPARC_64. */
12876 || reloc_type == 54; /* R_SPARC_UA64. */
12877 case EM_X86_64:
12878 case EM_L1OM:
12879 case EM_K1OM:
12880 return reloc_type == 1; /* R_X86_64_64. */
12881 case EM_S390_OLD:
12882 case EM_S390:
12883 return reloc_type == 22; /* R_S390_64. */
12884 case EM_TILEGX:
12885 return reloc_type == 1; /* R_TILEGX_64. */
12886 case EM_MIPS:
12887 return reloc_type == 18; /* R_MIPS_64. */
12888 default:
12889 return FALSE;
12890 }
12891 }
12892
12893 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12894 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12895
12896 static bfd_boolean
12897 is_64bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12898 {
12899 switch (filedata->file_header.e_machine)
12900 {
12901 case EM_AARCH64:
12902 return reloc_type == 260; /* R_AARCH64_PREL64. */
12903 case EM_ALPHA:
12904 return reloc_type == 11; /* R_ALPHA_SREL64. */
12905 case EM_IA_64:
12906 return (reloc_type == 0x4e /* R_IA64_PCREL64MSB. */
12907 || reloc_type == 0x4f /* R_IA64_PCREL64LSB. */);
12908 case EM_PARISC:
12909 return reloc_type == 72; /* R_PARISC_PCREL64. */
12910 case EM_PPC64:
12911 return reloc_type == 44; /* R_PPC64_REL64. */
12912 case EM_SPARC32PLUS:
12913 case EM_SPARCV9:
12914 case EM_SPARC:
12915 return reloc_type == 46; /* R_SPARC_DISP64. */
12916 case EM_X86_64:
12917 case EM_L1OM:
12918 case EM_K1OM:
12919 return reloc_type == 24; /* R_X86_64_PC64. */
12920 case EM_S390_OLD:
12921 case EM_S390:
12922 return reloc_type == 23; /* R_S390_PC64. */
12923 case EM_TILEGX:
12924 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
12925 default:
12926 return FALSE;
12927 }
12928 }
12929
12930 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12931 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12932
12933 static bfd_boolean
12934 is_24bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12935 {
12936 switch (filedata->file_header.e_machine)
12937 {
12938 case EM_CYGNUS_MN10200:
12939 case EM_MN10200:
12940 return reloc_type == 4; /* R_MN10200_24. */
12941 case EM_FT32:
12942 return reloc_type == 5; /* R_FT32_20. */
12943 default:
12944 return FALSE;
12945 }
12946 }
12947
12948 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12949 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12950
12951 static bfd_boolean
12952 is_16bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12953 {
12954 /* Please keep this table alpha-sorted for ease of visual lookup. */
12955 switch (filedata->file_header.e_machine)
12956 {
12957 case EM_ARC:
12958 case EM_ARC_COMPACT:
12959 case EM_ARC_COMPACT2:
12960 return reloc_type == 2; /* R_ARC_16. */
12961 case EM_ADAPTEVA_EPIPHANY:
12962 return reloc_type == 5;
12963 case EM_AVR_OLD:
12964 case EM_AVR:
12965 return reloc_type == 4; /* R_AVR_16. */
12966 case EM_CYGNUS_D10V:
12967 case EM_D10V:
12968 return reloc_type == 3; /* R_D10V_16. */
12969 case EM_FT32:
12970 return reloc_type == 2; /* R_FT32_16. */
12971 case EM_H8S:
12972 case EM_H8_300:
12973 case EM_H8_300H:
12974 return reloc_type == R_H8_DIR16;
12975 case EM_IP2K_OLD:
12976 case EM_IP2K:
12977 return reloc_type == 1; /* R_IP2K_16. */
12978 case EM_M32C_OLD:
12979 case EM_M32C:
12980 return reloc_type == 1; /* R_M32C_16 */
12981 case EM_CYGNUS_MN10200:
12982 case EM_MN10200:
12983 return reloc_type == 2; /* R_MN10200_16. */
12984 case EM_CYGNUS_MN10300:
12985 case EM_MN10300:
12986 return reloc_type == 2; /* R_MN10300_16. */
12987 case EM_MSP430:
12988 if (uses_msp430x_relocs (filedata))
12989 return reloc_type == 2; /* R_MSP430_ABS16. */
12990 /* Fall through. */
12991 case EM_MSP430_OLD:
12992 return reloc_type == 5; /* R_MSP430_16_BYTE. */
12993 case EM_NDS32:
12994 return reloc_type == 19; /* R_NDS32_RELA. */
12995 case EM_ALTERA_NIOS2:
12996 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
12997 case EM_NIOS32:
12998 return reloc_type == 9; /* R_NIOS_16. */
12999 case EM_OR1K:
13000 return reloc_type == 2; /* R_OR1K_16. */
13001 case EM_RISCV:
13002 return reloc_type == 55; /* R_RISCV_SET16. */
13003 case EM_TI_PRU:
13004 return reloc_type == 8; /* R_PRU_BFD_RELOC_16. */
13005 case EM_TI_C6000:
13006 return reloc_type == 2; /* R_C6000_ABS16. */
13007 case EM_VISIUM:
13008 return reloc_type == 2; /* R_VISIUM_16. */
13009 case EM_XC16X:
13010 case EM_C166:
13011 return reloc_type == 2; /* R_XC16C_ABS_16. */
13012 case EM_XGATE:
13013 return reloc_type == 3; /* R_XGATE_16. */
13014 default:
13015 return FALSE;
13016 }
13017 }
13018
13019 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13020 a 8-bit absolute RELA relocation used in DWARF debug sections. */
13021
13022 static bfd_boolean
13023 is_8bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
13024 {
13025 switch (filedata->file_header.e_machine)
13026 {
13027 case EM_RISCV:
13028 return reloc_type == 54; /* R_RISCV_SET8. */
13029 default:
13030 return FALSE;
13031 }
13032 }
13033
13034 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13035 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13036
13037 static bfd_boolean
13038 is_6bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
13039 {
13040 switch (filedata->file_header.e_machine)
13041 {
13042 case EM_RISCV:
13043 return reloc_type == 53; /* R_RISCV_SET6. */
13044 default:
13045 return FALSE;
13046 }
13047 }
13048
13049 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13050 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13051
13052 static bfd_boolean
13053 is_32bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13054 {
13055 /* Please keep this table alpha-sorted for ease of visual lookup. */
13056 switch (filedata->file_header.e_machine)
13057 {
13058 case EM_RISCV:
13059 return reloc_type == 35; /* R_RISCV_ADD32. */
13060 default:
13061 return FALSE;
13062 }
13063 }
13064
13065 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13066 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
13067
13068 static bfd_boolean
13069 is_32bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13070 {
13071 /* Please keep this table alpha-sorted for ease of visual lookup. */
13072 switch (filedata->file_header.e_machine)
13073 {
13074 case EM_RISCV:
13075 return reloc_type == 39; /* R_RISCV_SUB32. */
13076 default:
13077 return FALSE;
13078 }
13079 }
13080
13081 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13082 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
13083
13084 static bfd_boolean
13085 is_64bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13086 {
13087 /* Please keep this table alpha-sorted for ease of visual lookup. */
13088 switch (filedata->file_header.e_machine)
13089 {
13090 case EM_RISCV:
13091 return reloc_type == 36; /* R_RISCV_ADD64. */
13092 default:
13093 return FALSE;
13094 }
13095 }
13096
13097 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13098 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13099
13100 static bfd_boolean
13101 is_64bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13102 {
13103 /* Please keep this table alpha-sorted for ease of visual lookup. */
13104 switch (filedata->file_header.e_machine)
13105 {
13106 case EM_RISCV:
13107 return reloc_type == 40; /* R_RISCV_SUB64. */
13108 default:
13109 return FALSE;
13110 }
13111 }
13112
13113 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13114 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
13115
13116 static bfd_boolean
13117 is_16bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13118 {
13119 /* Please keep this table alpha-sorted for ease of visual lookup. */
13120 switch (filedata->file_header.e_machine)
13121 {
13122 case EM_RISCV:
13123 return reloc_type == 34; /* R_RISCV_ADD16. */
13124 default:
13125 return FALSE;
13126 }
13127 }
13128
13129 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13130 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
13131
13132 static bfd_boolean
13133 is_16bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13134 {
13135 /* Please keep this table alpha-sorted for ease of visual lookup. */
13136 switch (filedata->file_header.e_machine)
13137 {
13138 case EM_RISCV:
13139 return reloc_type == 38; /* R_RISCV_SUB16. */
13140 default:
13141 return FALSE;
13142 }
13143 }
13144
13145 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13146 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
13147
13148 static bfd_boolean
13149 is_8bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13150 {
13151 /* Please keep this table alpha-sorted for ease of visual lookup. */
13152 switch (filedata->file_header.e_machine)
13153 {
13154 case EM_RISCV:
13155 return reloc_type == 33; /* R_RISCV_ADD8. */
13156 default:
13157 return FALSE;
13158 }
13159 }
13160
13161 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13162 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
13163
13164 static bfd_boolean
13165 is_8bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13166 {
13167 /* Please keep this table alpha-sorted for ease of visual lookup. */
13168 switch (filedata->file_header.e_machine)
13169 {
13170 case EM_RISCV:
13171 return reloc_type == 37; /* R_RISCV_SUB8. */
13172 default:
13173 return FALSE;
13174 }
13175 }
13176
13177 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13178 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
13179
13180 static bfd_boolean
13181 is_6bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13182 {
13183 switch (filedata->file_header.e_machine)
13184 {
13185 case EM_RISCV:
13186 return reloc_type == 52; /* R_RISCV_SUB6. */
13187 default:
13188 return FALSE;
13189 }
13190 }
13191
13192 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13193 relocation entries (possibly formerly used for SHT_GROUP sections). */
13194
13195 static bfd_boolean
13196 is_none_reloc (Filedata * filedata, unsigned int reloc_type)
13197 {
13198 switch (filedata->file_header.e_machine)
13199 {
13200 case EM_386: /* R_386_NONE. */
13201 case EM_68K: /* R_68K_NONE. */
13202 case EM_ADAPTEVA_EPIPHANY:
13203 case EM_ALPHA: /* R_ALPHA_NONE. */
13204 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
13205 case EM_ARC: /* R_ARC_NONE. */
13206 case EM_ARC_COMPACT2: /* R_ARC_NONE. */
13207 case EM_ARC_COMPACT: /* R_ARC_NONE. */
13208 case EM_ARM: /* R_ARM_NONE. */
13209 case EM_C166: /* R_XC16X_NONE. */
13210 case EM_CRIS: /* R_CRIS_NONE. */
13211 case EM_FT32: /* R_FT32_NONE. */
13212 case EM_IA_64: /* R_IA64_NONE. */
13213 case EM_K1OM: /* R_X86_64_NONE. */
13214 case EM_L1OM: /* R_X86_64_NONE. */
13215 case EM_M32R: /* R_M32R_NONE. */
13216 case EM_MIPS: /* R_MIPS_NONE. */
13217 case EM_MN10300: /* R_MN10300_NONE. */
13218 case EM_MOXIE: /* R_MOXIE_NONE. */
13219 case EM_NIOS32: /* R_NIOS_NONE. */
13220 case EM_OR1K: /* R_OR1K_NONE. */
13221 case EM_PARISC: /* R_PARISC_NONE. */
13222 case EM_PPC64: /* R_PPC64_NONE. */
13223 case EM_PPC: /* R_PPC_NONE. */
13224 case EM_RISCV: /* R_RISCV_NONE. */
13225 case EM_S390: /* R_390_NONE. */
13226 case EM_S390_OLD:
13227 case EM_SH: /* R_SH_NONE. */
13228 case EM_SPARC32PLUS:
13229 case EM_SPARC: /* R_SPARC_NONE. */
13230 case EM_SPARCV9:
13231 case EM_TILEGX: /* R_TILEGX_NONE. */
13232 case EM_TILEPRO: /* R_TILEPRO_NONE. */
13233 case EM_TI_C6000:/* R_C6000_NONE. */
13234 case EM_X86_64: /* R_X86_64_NONE. */
13235 case EM_XC16X:
13236 case EM_WEBASSEMBLY: /* R_WASM32_NONE. */
13237 return reloc_type == 0;
13238
13239 case EM_AARCH64:
13240 return reloc_type == 0 || reloc_type == 256;
13241 case EM_AVR_OLD:
13242 case EM_AVR:
13243 return (reloc_type == 0 /* R_AVR_NONE. */
13244 || reloc_type == 30 /* R_AVR_DIFF8. */
13245 || reloc_type == 31 /* R_AVR_DIFF16. */
13246 || reloc_type == 32 /* R_AVR_DIFF32. */);
13247 case EM_METAG:
13248 return reloc_type == 3; /* R_METAG_NONE. */
13249 case EM_NDS32:
13250 return (reloc_type == 0 /* R_XTENSA_NONE. */
13251 || reloc_type == 204 /* R_NDS32_DIFF8. */
13252 || reloc_type == 205 /* R_NDS32_DIFF16. */
13253 || reloc_type == 206 /* R_NDS32_DIFF32. */
13254 || reloc_type == 207 /* R_NDS32_ULEB128. */);
13255 case EM_TI_PRU:
13256 return (reloc_type == 0 /* R_PRU_NONE. */
13257 || reloc_type == 65 /* R_PRU_DIFF8. */
13258 || reloc_type == 66 /* R_PRU_DIFF16. */
13259 || reloc_type == 67 /* R_PRU_DIFF32. */);
13260 case EM_XTENSA_OLD:
13261 case EM_XTENSA:
13262 return (reloc_type == 0 /* R_XTENSA_NONE. */
13263 || reloc_type == 17 /* R_XTENSA_DIFF8. */
13264 || reloc_type == 18 /* R_XTENSA_DIFF16. */
13265 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
13266 }
13267 return FALSE;
13268 }
13269
13270 /* Returns TRUE if there is a relocation against
13271 section NAME at OFFSET bytes. */
13272
13273 bfd_boolean
13274 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
13275 {
13276 Elf_Internal_Rela * relocs;
13277 Elf_Internal_Rela * rp;
13278
13279 if (dsec == NULL || dsec->reloc_info == NULL)
13280 return FALSE;
13281
13282 relocs = (Elf_Internal_Rela *) dsec->reloc_info;
13283
13284 for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
13285 if (rp->r_offset == offset)
13286 return TRUE;
13287
13288 return FALSE;
13289 }
13290
13291 /* Apply relocations to a section.
13292 Returns TRUE upon success, FALSE otherwise.
13293 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13294 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13295 will be set to the number of relocs loaded.
13296
13297 Note: So far support has been added only for those relocations
13298 which can be found in debug sections. FIXME: Add support for
13299 more relocations ? */
13300
13301 static bfd_boolean
13302 apply_relocations (Filedata * filedata,
13303 const Elf_Internal_Shdr * section,
13304 unsigned char * start,
13305 bfd_size_type size,
13306 void ** relocs_return,
13307 unsigned long * num_relocs_return)
13308 {
13309 Elf_Internal_Shdr * relsec;
13310 unsigned char * end = start + size;
13311
13312 if (relocs_return != NULL)
13313 {
13314 * (Elf_Internal_Rela **) relocs_return = NULL;
13315 * num_relocs_return = 0;
13316 }
13317
13318 if (filedata->file_header.e_type != ET_REL)
13319 /* No relocs to apply. */
13320 return TRUE;
13321
13322 /* Find the reloc section associated with the section. */
13323 for (relsec = filedata->section_headers;
13324 relsec < filedata->section_headers + filedata->file_header.e_shnum;
13325 ++relsec)
13326 {
13327 bfd_boolean is_rela;
13328 unsigned long num_relocs;
13329 Elf_Internal_Rela * relocs;
13330 Elf_Internal_Rela * rp;
13331 Elf_Internal_Shdr * symsec;
13332 Elf_Internal_Sym * symtab;
13333 unsigned long num_syms;
13334 Elf_Internal_Sym * sym;
13335
13336 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13337 || relsec->sh_info >= filedata->file_header.e_shnum
13338 || filedata->section_headers + relsec->sh_info != section
13339 || relsec->sh_size == 0
13340 || relsec->sh_link >= filedata->file_header.e_shnum)
13341 continue;
13342
13343 is_rela = relsec->sh_type == SHT_RELA;
13344
13345 if (is_rela)
13346 {
13347 if (!slurp_rela_relocs (filedata, relsec->sh_offset,
13348 relsec->sh_size, & relocs, & num_relocs))
13349 return FALSE;
13350 }
13351 else
13352 {
13353 if (!slurp_rel_relocs (filedata, relsec->sh_offset,
13354 relsec->sh_size, & relocs, & num_relocs))
13355 return FALSE;
13356 }
13357
13358 /* SH uses RELA but uses in place value instead of the addend field. */
13359 if (filedata->file_header.e_machine == EM_SH)
13360 is_rela = FALSE;
13361
13362 symsec = filedata->section_headers + relsec->sh_link;
13363 if (symsec->sh_type != SHT_SYMTAB
13364 && symsec->sh_type != SHT_DYNSYM)
13365 return FALSE;
13366 symtab = GET_ELF_SYMBOLS (filedata, symsec, & num_syms);
13367
13368 for (rp = relocs; rp < relocs + num_relocs; ++rp)
13369 {
13370 bfd_vma addend;
13371 unsigned int reloc_type;
13372 unsigned int reloc_size;
13373 bfd_boolean reloc_inplace = FALSE;
13374 bfd_boolean reloc_subtract = FALSE;
13375 unsigned char * rloc;
13376 unsigned long sym_index;
13377
13378 reloc_type = get_reloc_type (filedata, rp->r_info);
13379
13380 if (target_specific_reloc_handling (filedata, rp, start, end, symtab, num_syms))
13381 continue;
13382 else if (is_none_reloc (filedata, reloc_type))
13383 continue;
13384 else if (is_32bit_abs_reloc (filedata, reloc_type)
13385 || is_32bit_pcrel_reloc (filedata, reloc_type))
13386 reloc_size = 4;
13387 else if (is_64bit_abs_reloc (filedata, reloc_type)
13388 || is_64bit_pcrel_reloc (filedata, reloc_type))
13389 reloc_size = 8;
13390 else if (is_24bit_abs_reloc (filedata, reloc_type))
13391 reloc_size = 3;
13392 else if (is_16bit_abs_reloc (filedata, reloc_type))
13393 reloc_size = 2;
13394 else if (is_8bit_abs_reloc (filedata, reloc_type)
13395 || is_6bit_abs_reloc (filedata, reloc_type))
13396 reloc_size = 1;
13397 else if ((reloc_subtract = is_32bit_inplace_sub_reloc (filedata,
13398 reloc_type))
13399 || is_32bit_inplace_add_reloc (filedata, reloc_type))
13400 {
13401 reloc_size = 4;
13402 reloc_inplace = TRUE;
13403 }
13404 else if ((reloc_subtract = is_64bit_inplace_sub_reloc (filedata,
13405 reloc_type))
13406 || is_64bit_inplace_add_reloc (filedata, reloc_type))
13407 {
13408 reloc_size = 8;
13409 reloc_inplace = TRUE;
13410 }
13411 else if ((reloc_subtract = is_16bit_inplace_sub_reloc (filedata,
13412 reloc_type))
13413 || is_16bit_inplace_add_reloc (filedata, reloc_type))
13414 {
13415 reloc_size = 2;
13416 reloc_inplace = TRUE;
13417 }
13418 else if ((reloc_subtract = is_8bit_inplace_sub_reloc (filedata,
13419 reloc_type))
13420 || is_8bit_inplace_add_reloc (filedata, reloc_type))
13421 {
13422 reloc_size = 1;
13423 reloc_inplace = TRUE;
13424 }
13425 else if ((reloc_subtract = is_6bit_inplace_sub_reloc (filedata,
13426 reloc_type)))
13427 {
13428 reloc_size = 1;
13429 reloc_inplace = TRUE;
13430 }
13431 else
13432 {
13433 static unsigned int prev_reloc = 0;
13434
13435 if (reloc_type != prev_reloc)
13436 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13437 reloc_type, printable_section_name (filedata, section));
13438 prev_reloc = reloc_type;
13439 continue;
13440 }
13441
13442 rloc = start + rp->r_offset;
13443 if (!IN_RANGE (start, end, rloc, reloc_size))
13444 {
13445 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13446 (unsigned long) rp->r_offset,
13447 printable_section_name (filedata, section));
13448 continue;
13449 }
13450
13451 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
13452 if (sym_index >= num_syms)
13453 {
13454 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13455 sym_index, printable_section_name (filedata, section));
13456 continue;
13457 }
13458 sym = symtab + sym_index;
13459
13460 /* If the reloc has a symbol associated with it,
13461 make sure that it is of an appropriate type.
13462
13463 Relocations against symbols without type can happen.
13464 Gcc -feliminate-dwarf2-dups may generate symbols
13465 without type for debug info.
13466
13467 Icc generates relocations against function symbols
13468 instead of local labels.
13469
13470 Relocations against object symbols can happen, eg when
13471 referencing a global array. For an example of this see
13472 the _clz.o binary in libgcc.a. */
13473 if (sym != symtab
13474 && ELF_ST_TYPE (sym->st_info) != STT_COMMON
13475 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
13476 {
13477 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13478 get_symbol_type (filedata, ELF_ST_TYPE (sym->st_info)),
13479 printable_section_name (filedata, relsec),
13480 (long int)(rp - relocs));
13481 continue;
13482 }
13483
13484 addend = 0;
13485 if (is_rela)
13486 addend += rp->r_addend;
13487 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13488 partial_inplace. */
13489 if (!is_rela
13490 || (filedata->file_header.e_machine == EM_XTENSA
13491 && reloc_type == 1)
13492 || ((filedata->file_header.e_machine == EM_PJ
13493 || filedata->file_header.e_machine == EM_PJ_OLD)
13494 && reloc_type == 1)
13495 || ((filedata->file_header.e_machine == EM_D30V
13496 || filedata->file_header.e_machine == EM_CYGNUS_D30V)
13497 && reloc_type == 12)
13498 || reloc_inplace)
13499 {
13500 if (is_6bit_inplace_sub_reloc (filedata, reloc_type))
13501 addend += byte_get (rloc, reloc_size) & 0x3f;
13502 else
13503 addend += byte_get (rloc, reloc_size);
13504 }
13505
13506 if (is_32bit_pcrel_reloc (filedata, reloc_type)
13507 || is_64bit_pcrel_reloc (filedata, reloc_type))
13508 {
13509 /* On HPPA, all pc-relative relocations are biased by 8. */
13510 if (filedata->file_header.e_machine == EM_PARISC)
13511 addend -= 8;
13512 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
13513 reloc_size);
13514 }
13515 else if (is_6bit_abs_reloc (filedata, reloc_type)
13516 || is_6bit_inplace_sub_reloc (filedata, reloc_type))
13517 {
13518 if (reloc_subtract)
13519 addend -= sym->st_value;
13520 else
13521 addend += sym->st_value;
13522 addend = (addend & 0x3f) | (byte_get (rloc, reloc_size) & 0xc0);
13523 byte_put (rloc, addend, reloc_size);
13524 }
13525 else if (reloc_subtract)
13526 byte_put (rloc, addend - sym->st_value, reloc_size);
13527 else
13528 byte_put (rloc, addend + sym->st_value, reloc_size);
13529 }
13530
13531 free (symtab);
13532 /* Let the target specific reloc processing code know that
13533 we have finished with these relocs. */
13534 target_specific_reloc_handling (filedata, NULL, NULL, NULL, NULL, 0);
13535
13536 if (relocs_return)
13537 {
13538 * (Elf_Internal_Rela **) relocs_return = relocs;
13539 * num_relocs_return = num_relocs;
13540 }
13541 else
13542 free (relocs);
13543
13544 break;
13545 }
13546
13547 return TRUE;
13548 }
13549
13550 #ifdef SUPPORT_DISASSEMBLY
13551 static bfd_boolean
13552 disassemble_section (Elf_Internal_Shdr * section, Filedata * filedata)
13553 {
13554 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata, section));
13555
13556 /* FIXME: XXX -- to be done --- XXX */
13557
13558 return TRUE;
13559 }
13560 #endif
13561
13562 /* Reads in the contents of SECTION from FILE, returning a pointer
13563 to a malloc'ed buffer or NULL if something went wrong. */
13564
13565 static char *
13566 get_section_contents (Elf_Internal_Shdr * section, Filedata * filedata)
13567 {
13568 bfd_size_type num_bytes = section->sh_size;
13569
13570 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
13571 {
13572 printf (_("Section '%s' has no data to dump.\n"),
13573 printable_section_name (filedata, section));
13574 return NULL;
13575 }
13576
13577 return (char *) get_data (NULL, filedata, section->sh_offset, 1, num_bytes,
13578 _("section contents"));
13579 }
13580
13581 /* Uncompresses a section that was compressed using zlib, in place. */
13582
13583 static bfd_boolean
13584 uncompress_section_contents (unsigned char ** buffer,
13585 dwarf_size_type uncompressed_size,
13586 dwarf_size_type * size)
13587 {
13588 dwarf_size_type compressed_size = *size;
13589 unsigned char * compressed_buffer = *buffer;
13590 unsigned char * uncompressed_buffer;
13591 z_stream strm;
13592 int rc;
13593
13594 /* It is possible the section consists of several compressed
13595 buffers concatenated together, so we uncompress in a loop. */
13596 /* PR 18313: The state field in the z_stream structure is supposed
13597 to be invisible to the user (ie us), but some compilers will
13598 still complain about it being used without initialisation. So
13599 we first zero the entire z_stream structure and then set the fields
13600 that we need. */
13601 memset (& strm, 0, sizeof strm);
13602 strm.avail_in = compressed_size;
13603 strm.next_in = (Bytef *) compressed_buffer;
13604 strm.avail_out = uncompressed_size;
13605 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
13606
13607 rc = inflateInit (& strm);
13608 while (strm.avail_in > 0)
13609 {
13610 if (rc != Z_OK)
13611 goto fail;
13612 strm.next_out = ((Bytef *) uncompressed_buffer
13613 + (uncompressed_size - strm.avail_out));
13614 rc = inflate (&strm, Z_FINISH);
13615 if (rc != Z_STREAM_END)
13616 goto fail;
13617 rc = inflateReset (& strm);
13618 }
13619 rc = inflateEnd (& strm);
13620 if (rc != Z_OK
13621 || strm.avail_out != 0)
13622 goto fail;
13623
13624 *buffer = uncompressed_buffer;
13625 *size = uncompressed_size;
13626 return TRUE;
13627
13628 fail:
13629 free (uncompressed_buffer);
13630 /* Indicate decompression failure. */
13631 *buffer = NULL;
13632 return FALSE;
13633 }
13634
13635 static bfd_boolean
13636 dump_section_as_strings (Elf_Internal_Shdr * section, Filedata * filedata)
13637 {
13638 Elf_Internal_Shdr * relsec;
13639 bfd_size_type num_bytes;
13640 unsigned char * data;
13641 unsigned char * end;
13642 unsigned char * real_start;
13643 unsigned char * start;
13644 bfd_boolean some_strings_shown;
13645
13646 real_start = start = (unsigned char *) get_section_contents (section, filedata);
13647 if (start == NULL)
13648 /* PR 21820: Do not fail if the section was empty. */
13649 return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13650
13651 num_bytes = section->sh_size;
13652
13653 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata, section));
13654
13655 if (decompress_dumps)
13656 {
13657 dwarf_size_type new_size = num_bytes;
13658 dwarf_size_type uncompressed_size = 0;
13659
13660 if ((section->sh_flags & SHF_COMPRESSED) != 0)
13661 {
13662 Elf_Internal_Chdr chdr;
13663 unsigned int compression_header_size
13664 = get_compression_header (& chdr, (unsigned char *) start,
13665 num_bytes);
13666
13667 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13668 {
13669 warn (_("section '%s' has unsupported compress type: %d\n"),
13670 printable_section_name (filedata, section), chdr.ch_type);
13671 return FALSE;
13672 }
13673 uncompressed_size = chdr.ch_size;
13674 start += compression_header_size;
13675 new_size -= compression_header_size;
13676 }
13677 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13678 {
13679 /* Read the zlib header. In this case, it should be "ZLIB"
13680 followed by the uncompressed section size, 8 bytes in
13681 big-endian order. */
13682 uncompressed_size = start[4]; uncompressed_size <<= 8;
13683 uncompressed_size += start[5]; uncompressed_size <<= 8;
13684 uncompressed_size += start[6]; uncompressed_size <<= 8;
13685 uncompressed_size += start[7]; uncompressed_size <<= 8;
13686 uncompressed_size += start[8]; uncompressed_size <<= 8;
13687 uncompressed_size += start[9]; uncompressed_size <<= 8;
13688 uncompressed_size += start[10]; uncompressed_size <<= 8;
13689 uncompressed_size += start[11];
13690 start += 12;
13691 new_size -= 12;
13692 }
13693
13694 if (uncompressed_size)
13695 {
13696 if (uncompress_section_contents (& start,
13697 uncompressed_size, & new_size))
13698 num_bytes = new_size;
13699 else
13700 {
13701 error (_("Unable to decompress section %s\n"),
13702 printable_section_name (filedata, section));
13703 return FALSE;
13704 }
13705 }
13706 else
13707 start = real_start;
13708 }
13709
13710 /* If the section being dumped has relocations against it the user might
13711 be expecting these relocations to have been applied. Check for this
13712 case and issue a warning message in order to avoid confusion.
13713 FIXME: Maybe we ought to have an option that dumps a section with
13714 relocs applied ? */
13715 for (relsec = filedata->section_headers;
13716 relsec < filedata->section_headers + filedata->file_header.e_shnum;
13717 ++relsec)
13718 {
13719 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13720 || relsec->sh_info >= filedata->file_header.e_shnum
13721 || filedata->section_headers + relsec->sh_info != section
13722 || relsec->sh_size == 0
13723 || relsec->sh_link >= filedata->file_header.e_shnum)
13724 continue;
13725
13726 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13727 break;
13728 }
13729
13730 data = start;
13731 end = start + num_bytes;
13732 some_strings_shown = FALSE;
13733
13734 while (data < end)
13735 {
13736 while (!ISPRINT (* data))
13737 if (++ data >= end)
13738 break;
13739
13740 if (data < end)
13741 {
13742 size_t maxlen = end - data;
13743
13744 #ifndef __MSVCRT__
13745 /* PR 11128: Use two separate invocations in order to work
13746 around bugs in the Solaris 8 implementation of printf. */
13747 printf (" [%6tx] ", data - start);
13748 #else
13749 printf (" [%6Ix] ", (size_t) (data - start));
13750 #endif
13751 if (maxlen > 0)
13752 {
13753 print_symbol ((int) maxlen, (const char *) data);
13754 putchar ('\n');
13755 data += strnlen ((const char *) data, maxlen);
13756 }
13757 else
13758 {
13759 printf (_("<corrupt>\n"));
13760 data = end;
13761 }
13762 some_strings_shown = TRUE;
13763 }
13764 }
13765
13766 if (! some_strings_shown)
13767 printf (_(" No strings found in this section."));
13768
13769 free (real_start);
13770
13771 putchar ('\n');
13772 return TRUE;
13773 }
13774
13775 static bfd_boolean
13776 dump_section_as_bytes (Elf_Internal_Shdr * section,
13777 Filedata * filedata,
13778 bfd_boolean relocate)
13779 {
13780 Elf_Internal_Shdr * relsec;
13781 bfd_size_type bytes;
13782 bfd_size_type section_size;
13783 bfd_vma addr;
13784 unsigned char * data;
13785 unsigned char * real_start;
13786 unsigned char * start;
13787
13788 real_start = start = (unsigned char *) get_section_contents (section, filedata);
13789 if (start == NULL)
13790 /* PR 21820: Do not fail if the section was empty. */
13791 return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13792
13793 section_size = section->sh_size;
13794
13795 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata, section));
13796
13797 if (decompress_dumps)
13798 {
13799 dwarf_size_type new_size = section_size;
13800 dwarf_size_type uncompressed_size = 0;
13801
13802 if ((section->sh_flags & SHF_COMPRESSED) != 0)
13803 {
13804 Elf_Internal_Chdr chdr;
13805 unsigned int compression_header_size
13806 = get_compression_header (& chdr, start, section_size);
13807
13808 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13809 {
13810 warn (_("section '%s' has unsupported compress type: %d\n"),
13811 printable_section_name (filedata, section), chdr.ch_type);
13812 return FALSE;
13813 }
13814 uncompressed_size = chdr.ch_size;
13815 start += compression_header_size;
13816 new_size -= compression_header_size;
13817 }
13818 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13819 {
13820 /* Read the zlib header. In this case, it should be "ZLIB"
13821 followed by the uncompressed section size, 8 bytes in
13822 big-endian order. */
13823 uncompressed_size = start[4]; uncompressed_size <<= 8;
13824 uncompressed_size += start[5]; uncompressed_size <<= 8;
13825 uncompressed_size += start[6]; uncompressed_size <<= 8;
13826 uncompressed_size += start[7]; uncompressed_size <<= 8;
13827 uncompressed_size += start[8]; uncompressed_size <<= 8;
13828 uncompressed_size += start[9]; uncompressed_size <<= 8;
13829 uncompressed_size += start[10]; uncompressed_size <<= 8;
13830 uncompressed_size += start[11];
13831 start += 12;
13832 new_size -= 12;
13833 }
13834
13835 if (uncompressed_size)
13836 {
13837 if (uncompress_section_contents (& start, uncompressed_size,
13838 & new_size))
13839 {
13840 section_size = new_size;
13841 }
13842 else
13843 {
13844 error (_("Unable to decompress section %s\n"),
13845 printable_section_name (filedata, section));
13846 /* FIXME: Print the section anyway ? */
13847 return FALSE;
13848 }
13849 }
13850 else
13851 start = real_start;
13852 }
13853
13854 if (relocate)
13855 {
13856 if (! apply_relocations (filedata, section, start, section_size, NULL, NULL))
13857 return FALSE;
13858 }
13859 else
13860 {
13861 /* If the section being dumped has relocations against it the user might
13862 be expecting these relocations to have been applied. Check for this
13863 case and issue a warning message in order to avoid confusion.
13864 FIXME: Maybe we ought to have an option that dumps a section with
13865 relocs applied ? */
13866 for (relsec = filedata->section_headers;
13867 relsec < filedata->section_headers + filedata->file_header.e_shnum;
13868 ++relsec)
13869 {
13870 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13871 || relsec->sh_info >= filedata->file_header.e_shnum
13872 || filedata->section_headers + relsec->sh_info != section
13873 || relsec->sh_size == 0
13874 || relsec->sh_link >= filedata->file_header.e_shnum)
13875 continue;
13876
13877 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13878 break;
13879 }
13880 }
13881
13882 addr = section->sh_addr;
13883 bytes = section_size;
13884 data = start;
13885
13886 while (bytes)
13887 {
13888 int j;
13889 int k;
13890 int lbytes;
13891
13892 lbytes = (bytes > 16 ? 16 : bytes);
13893
13894 printf (" 0x%8.8lx ", (unsigned long) addr);
13895
13896 for (j = 0; j < 16; j++)
13897 {
13898 if (j < lbytes)
13899 printf ("%2.2x", data[j]);
13900 else
13901 printf (" ");
13902
13903 if ((j & 3) == 3)
13904 printf (" ");
13905 }
13906
13907 for (j = 0; j < lbytes; j++)
13908 {
13909 k = data[j];
13910 if (k >= ' ' && k < 0x7f)
13911 printf ("%c", k);
13912 else
13913 printf (".");
13914 }
13915
13916 putchar ('\n');
13917
13918 data += lbytes;
13919 addr += lbytes;
13920 bytes -= lbytes;
13921 }
13922
13923 free (real_start);
13924
13925 putchar ('\n');
13926 return TRUE;
13927 }
13928
13929 static ctf_sect_t *
13930 shdr_to_ctf_sect (ctf_sect_t *buf, Elf_Internal_Shdr *shdr, Filedata *filedata)
13931 {
13932 buf->cts_name = SECTION_NAME (shdr);
13933 buf->cts_size = shdr->sh_size;
13934 buf->cts_entsize = shdr->sh_entsize;
13935
13936 return buf;
13937 }
13938
13939 /* Formatting callback function passed to ctf_dump. Returns either the pointer
13940 it is passed, or a pointer to newly-allocated storage, in which case
13941 dump_ctf() will free it when it no longer needs it. */
13942
13943 static char *dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED,
13944 char *s, void *arg)
13945 {
13946 const char *blanks = arg;
13947 char *new_s;
13948
13949 if (asprintf (&new_s, "%s%s", blanks, s) < 0)
13950 return s;
13951 return new_s;
13952 }
13953
13954 static bfd_boolean
13955 dump_section_as_ctf (Elf_Internal_Shdr * section, Filedata * filedata)
13956 {
13957 Elf_Internal_Shdr * parent_sec = NULL;
13958 Elf_Internal_Shdr * symtab_sec = NULL;
13959 Elf_Internal_Shdr * strtab_sec = NULL;
13960 void * data = NULL;
13961 void * symdata = NULL;
13962 void * strdata = NULL;
13963 void * parentdata = NULL;
13964 ctf_sect_t ctfsect, symsect, strsect, parentsect;
13965 ctf_sect_t * symsectp = NULL;
13966 ctf_sect_t * strsectp = NULL;
13967 ctf_file_t * ctf = NULL;
13968 ctf_file_t * parent = NULL;
13969
13970 const char *things[] = {"Header", "Labels", "Data objects",
13971 "Function objects", "Variables", "Types", "Strings",
13972 ""};
13973 const char **thing;
13974 int err;
13975 bfd_boolean ret = FALSE;
13976 size_t i;
13977
13978 shdr_to_ctf_sect (&ctfsect, section, filedata);
13979 data = get_section_contents (section, filedata);
13980 ctfsect.cts_data = data;
13981
13982 if (!dump_ctf_symtab_name)
13983 dump_ctf_symtab_name = strdup (".symtab");
13984
13985 if (!dump_ctf_strtab_name)
13986 dump_ctf_strtab_name = strdup (".strtab");
13987
13988 if (dump_ctf_symtab_name && dump_ctf_symtab_name[0] != 0)
13989 {
13990 if ((symtab_sec = find_section (filedata, dump_ctf_symtab_name)) == NULL)
13991 {
13992 error (_("No symbol section named %s\n"), dump_ctf_symtab_name);
13993 goto fail;
13994 }
13995 if ((symdata = (void *) get_data (NULL, filedata,
13996 symtab_sec->sh_offset, 1,
13997 symtab_sec->sh_size,
13998 _("symbols"))) == NULL)
13999 goto fail;
14000 symsectp = shdr_to_ctf_sect (&symsect, symtab_sec, filedata);
14001 symsect.cts_data = symdata;
14002 }
14003 if (dump_ctf_strtab_name && dump_ctf_symtab_name[0] != 0)
14004 {
14005 if ((strtab_sec = find_section (filedata, dump_ctf_strtab_name)) == NULL)
14006 {
14007 error (_("No string table section named %s\n"),
14008 dump_ctf_strtab_name);
14009 goto fail;
14010 }
14011 if ((strdata = (void *) get_data (NULL, filedata,
14012 strtab_sec->sh_offset, 1,
14013 strtab_sec->sh_size,
14014 _("strings"))) == NULL)
14015 goto fail;
14016 strsectp = shdr_to_ctf_sect (&strsect, strtab_sec, filedata);
14017 strsect.cts_data = strdata;
14018 }
14019 if (dump_ctf_parent_name)
14020 {
14021 if ((parent_sec = find_section (filedata, dump_ctf_parent_name)) == NULL)
14022 {
14023 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name);
14024 goto fail;
14025 }
14026 if ((parentdata = (void *) get_data (NULL, filedata,
14027 parent_sec->sh_offset, 1,
14028 parent_sec->sh_size,
14029 _("CTF parent"))) == NULL)
14030 goto fail;
14031 shdr_to_ctf_sect (&parentsect, parent_sec, filedata);
14032 parentsect.cts_data = parentdata;
14033 }
14034
14035 /* Load the CTF file and dump it. */
14036
14037 if ((ctf = ctf_bufopen (&ctfsect, symsectp, strsectp, &err)) == NULL)
14038 {
14039 error (_("CTF open failure: %s\n"), ctf_errmsg (err));
14040 goto fail;
14041 }
14042
14043 if (parentdata)
14044 {
14045 if ((parent = ctf_bufopen (&parentsect, symsectp, strsectp, &err)) == NULL)
14046 {
14047 error (_("CTF open failure: %s\n"), ctf_errmsg (err));
14048 goto fail;
14049 }
14050
14051 ctf_import (ctf, parent);
14052 }
14053
14054 ret = TRUE;
14055
14056 printf (_("\nDump of CTF section '%s':\n"),
14057 printable_section_name (filedata, section));
14058
14059 for (i = 0, thing = things; *thing[0]; thing++, i++)
14060 {
14061 ctf_dump_state_t *s = NULL;
14062 char *item;
14063
14064 printf ("\n %s:\n", *thing);
14065 while ((item = ctf_dump (ctf, &s, i, dump_ctf_indent_lines,
14066 (void *) " ")) != NULL)
14067 {
14068 printf ("%s\n", item);
14069 free (item);
14070 }
14071
14072 if (ctf_errno (ctf))
14073 {
14074 error (_("Iteration failed: %s, %s\n"), *thing,
14075 ctf_errmsg (ctf_errno (ctf)));
14076 ret = FALSE;
14077 }
14078 }
14079
14080 fail:
14081 ctf_file_close (ctf);
14082 ctf_file_close (parent);
14083 free (parentdata);
14084 free (data);
14085 free (symdata);
14086 free (strdata);
14087 return ret;
14088 }
14089
14090 static bfd_boolean
14091 load_specific_debug_section (enum dwarf_section_display_enum debug,
14092 const Elf_Internal_Shdr * sec,
14093 void * data)
14094 {
14095 struct dwarf_section * section = &debug_displays [debug].section;
14096 char buf [64];
14097 Filedata * filedata = (Filedata *) data;
14098
14099 if (section->start != NULL)
14100 {
14101 /* If it is already loaded, do nothing. */
14102 if (streq (section->filename, filedata->file_name))
14103 return TRUE;
14104 free (section->start);
14105 }
14106
14107 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
14108 section->address = sec->sh_addr;
14109 section->user_data = NULL;
14110 section->filename = filedata->file_name;
14111 section->start = (unsigned char *) get_data (NULL, filedata,
14112 sec->sh_offset, 1,
14113 sec->sh_size, buf);
14114 if (section->start == NULL)
14115 section->size = 0;
14116 else
14117 {
14118 unsigned char *start = section->start;
14119 dwarf_size_type size = sec->sh_size;
14120 dwarf_size_type uncompressed_size = 0;
14121
14122 if ((sec->sh_flags & SHF_COMPRESSED) != 0)
14123 {
14124 Elf_Internal_Chdr chdr;
14125 unsigned int compression_header_size;
14126
14127 if (size < (is_32bit_elf
14128 ? sizeof (Elf32_External_Chdr)
14129 : sizeof (Elf64_External_Chdr)))
14130 {
14131 warn (_("compressed section %s is too small to contain a compression header"),
14132 section->name);
14133 return FALSE;
14134 }
14135
14136 compression_header_size = get_compression_header (&chdr, start, size);
14137
14138 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
14139 {
14140 warn (_("section '%s' has unsupported compress type: %d\n"),
14141 section->name, chdr.ch_type);
14142 return FALSE;
14143 }
14144 uncompressed_size = chdr.ch_size;
14145 start += compression_header_size;
14146 size -= compression_header_size;
14147 }
14148 else if (size > 12 && streq ((char *) start, "ZLIB"))
14149 {
14150 /* Read the zlib header. In this case, it should be "ZLIB"
14151 followed by the uncompressed section size, 8 bytes in
14152 big-endian order. */
14153 uncompressed_size = start[4]; uncompressed_size <<= 8;
14154 uncompressed_size += start[5]; uncompressed_size <<= 8;
14155 uncompressed_size += start[6]; uncompressed_size <<= 8;
14156 uncompressed_size += start[7]; uncompressed_size <<= 8;
14157 uncompressed_size += start[8]; uncompressed_size <<= 8;
14158 uncompressed_size += start[9]; uncompressed_size <<= 8;
14159 uncompressed_size += start[10]; uncompressed_size <<= 8;
14160 uncompressed_size += start[11];
14161 start += 12;
14162 size -= 12;
14163 }
14164
14165 if (uncompressed_size)
14166 {
14167 if (uncompress_section_contents (&start, uncompressed_size,
14168 &size))
14169 {
14170 /* Free the compressed buffer, update the section buffer
14171 and the section size if uncompress is successful. */
14172 free (section->start);
14173 section->start = start;
14174 }
14175 else
14176 {
14177 error (_("Unable to decompress section %s\n"),
14178 printable_section_name (filedata, sec));
14179 return FALSE;
14180 }
14181 }
14182
14183 section->size = size;
14184 }
14185
14186 if (section->start == NULL)
14187 return FALSE;
14188
14189 if (debug_displays [debug].relocate)
14190 {
14191 if (! apply_relocations (filedata, sec, section->start, section->size,
14192 & section->reloc_info, & section->num_relocs))
14193 return FALSE;
14194 }
14195 else
14196 {
14197 section->reloc_info = NULL;
14198 section->num_relocs = 0;
14199 }
14200
14201 return TRUE;
14202 }
14203
14204 /* If this is not NULL, load_debug_section will only look for sections
14205 within the list of sections given here. */
14206 static unsigned int * section_subset = NULL;
14207
14208 bfd_boolean
14209 load_debug_section (enum dwarf_section_display_enum debug, void * data)
14210 {
14211 struct dwarf_section * section = &debug_displays [debug].section;
14212 Elf_Internal_Shdr * sec;
14213 Filedata * filedata = (Filedata *) data;
14214
14215 /* Without section headers we cannot find any sections. */
14216 if (filedata->section_headers == NULL)
14217 return FALSE;
14218
14219 if (filedata->string_table == NULL
14220 && filedata->file_header.e_shstrndx != SHN_UNDEF
14221 && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
14222 {
14223 Elf_Internal_Shdr * strs;
14224
14225 /* Read in the string table, so that we have section names to scan. */
14226 strs = filedata->section_headers + filedata->file_header.e_shstrndx;
14227
14228 if (strs != NULL && strs->sh_size != 0)
14229 {
14230 filedata->string_table
14231 = (char *) get_data (NULL, filedata, strs->sh_offset,
14232 1, strs->sh_size, _("string table"));
14233
14234 filedata->string_table_length
14235 = filedata->string_table != NULL ? strs->sh_size : 0;
14236 }
14237 }
14238
14239 /* Locate the debug section. */
14240 sec = find_section_in_set (filedata, section->uncompressed_name, section_subset);
14241 if (sec != NULL)
14242 section->name = section->uncompressed_name;
14243 else
14244 {
14245 sec = find_section_in_set (filedata, section->compressed_name, section_subset);
14246 if (sec != NULL)
14247 section->name = section->compressed_name;
14248 }
14249 if (sec == NULL)
14250 return FALSE;
14251
14252 /* If we're loading from a subset of sections, and we've loaded
14253 a section matching this name before, it's likely that it's a
14254 different one. */
14255 if (section_subset != NULL)
14256 free_debug_section (debug);
14257
14258 return load_specific_debug_section (debug, sec, data);
14259 }
14260
14261 void
14262 free_debug_section (enum dwarf_section_display_enum debug)
14263 {
14264 struct dwarf_section * section = &debug_displays [debug].section;
14265
14266 if (section->start == NULL)
14267 return;
14268
14269 free ((char *) section->start);
14270 section->start = NULL;
14271 section->address = 0;
14272 section->size = 0;
14273 }
14274
14275 static bfd_boolean
14276 display_debug_section (int shndx, Elf_Internal_Shdr * section, Filedata * filedata)
14277 {
14278 char * name = SECTION_NAME (section);
14279 const char * print_name = printable_section_name (filedata, section);
14280 bfd_size_type length;
14281 bfd_boolean result = TRUE;
14282 int i;
14283
14284 length = section->sh_size;
14285 if (length == 0)
14286 {
14287 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
14288 return TRUE;
14289 }
14290 if (section->sh_type == SHT_NOBITS)
14291 {
14292 /* There is no point in dumping the contents of a debugging section
14293 which has the NOBITS type - the bits in the file will be random.
14294 This can happen when a file containing a .eh_frame section is
14295 stripped with the --only-keep-debug command line option. */
14296 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14297 print_name);
14298 return FALSE;
14299 }
14300
14301 if (const_strneq (name, ".gnu.linkonce.wi."))
14302 name = ".debug_info";
14303
14304 /* See if we know how to display the contents of this section. */
14305 for (i = 0; i < max; i++)
14306 {
14307 enum dwarf_section_display_enum id = (enum dwarf_section_display_enum) i;
14308 struct dwarf_section_display * display = debug_displays + i;
14309 struct dwarf_section * sec = & display->section;
14310
14311 if (streq (sec->uncompressed_name, name)
14312 || (id == line && const_strneq (name, ".debug_line."))
14313 || streq (sec->compressed_name, name))
14314 {
14315 bfd_boolean secondary = (section != find_section (filedata, name));
14316
14317 if (secondary)
14318 free_debug_section (id);
14319
14320 if (i == line && const_strneq (name, ".debug_line."))
14321 sec->name = name;
14322 else if (streq (sec->uncompressed_name, name))
14323 sec->name = sec->uncompressed_name;
14324 else
14325 sec->name = sec->compressed_name;
14326
14327 if (load_specific_debug_section (id, section, filedata))
14328 {
14329 /* If this debug section is part of a CU/TU set in a .dwp file,
14330 restrict load_debug_section to the sections in that set. */
14331 section_subset = find_cu_tu_set (filedata, shndx);
14332
14333 result &= display->display (sec, filedata);
14334
14335 section_subset = NULL;
14336
14337 if (secondary || (id != info && id != abbrev))
14338 free_debug_section (id);
14339 }
14340 break;
14341 }
14342 }
14343
14344 if (i == max)
14345 {
14346 printf (_("Unrecognized debug section: %s\n"), print_name);
14347 result = FALSE;
14348 }
14349
14350 return result;
14351 }
14352
14353 /* Set DUMP_SECTS for all sections where dumps were requested
14354 based on section name. */
14355
14356 static void
14357 initialise_dumps_byname (Filedata * filedata)
14358 {
14359 struct dump_list_entry * cur;
14360
14361 for (cur = dump_sects_byname; cur; cur = cur->next)
14362 {
14363 unsigned int i;
14364 bfd_boolean any = FALSE;
14365
14366 for (i = 0; i < filedata->file_header.e_shnum; i++)
14367 if (streq (SECTION_NAME (filedata->section_headers + i), cur->name))
14368 {
14369 request_dump_bynumber (filedata, i, cur->type);
14370 any = TRUE;
14371 }
14372
14373 if (!any)
14374 warn (_("Section '%s' was not dumped because it does not exist!\n"),
14375 cur->name);
14376 }
14377 }
14378
14379 static bfd_boolean
14380 process_section_contents (Filedata * filedata)
14381 {
14382 Elf_Internal_Shdr * section;
14383 unsigned int i;
14384 bfd_boolean res = TRUE;
14385
14386 if (! do_dump)
14387 return TRUE;
14388
14389 initialise_dumps_byname (filedata);
14390
14391 for (i = 0, section = filedata->section_headers;
14392 i < filedata->file_header.e_shnum && i < filedata->num_dump_sects;
14393 i++, section++)
14394 {
14395 dump_type dump = filedata->dump_sects[i];
14396
14397 #ifdef SUPPORT_DISASSEMBLY
14398 if (dump & DISASS_DUMP)
14399 {
14400 if (! disassemble_section (section, filedata))
14401 res = FALSE;
14402 }
14403 #endif
14404 if (dump & HEX_DUMP)
14405 {
14406 if (! dump_section_as_bytes (section, filedata, FALSE))
14407 res = FALSE;
14408 }
14409
14410 if (dump & RELOC_DUMP)
14411 {
14412 if (! dump_section_as_bytes (section, filedata, TRUE))
14413 res = FALSE;
14414 }
14415
14416 if (dump & STRING_DUMP)
14417 {
14418 if (! dump_section_as_strings (section, filedata))
14419 res = FALSE;
14420 }
14421
14422 if (dump & DEBUG_DUMP)
14423 {
14424 if (! display_debug_section (i, section, filedata))
14425 res = FALSE;
14426 }
14427
14428 if (dump & CTF_DUMP)
14429 {
14430 if (! dump_section_as_ctf (section, filedata))
14431 res = FALSE;
14432 }
14433 }
14434
14435 /* Check to see if the user requested a
14436 dump of a section that does not exist. */
14437 while (i < filedata->num_dump_sects)
14438 {
14439 if (filedata->dump_sects[i])
14440 {
14441 warn (_("Section %d was not dumped because it does not exist!\n"), i);
14442 res = FALSE;
14443 }
14444 i++;
14445 }
14446
14447 return res;
14448 }
14449
14450 static void
14451 process_mips_fpe_exception (int mask)
14452 {
14453 if (mask)
14454 {
14455 bfd_boolean first = TRUE;
14456
14457 if (mask & OEX_FPU_INEX)
14458 fputs ("INEX", stdout), first = FALSE;
14459 if (mask & OEX_FPU_UFLO)
14460 printf ("%sUFLO", first ? "" : "|"), first = FALSE;
14461 if (mask & OEX_FPU_OFLO)
14462 printf ("%sOFLO", first ? "" : "|"), first = FALSE;
14463 if (mask & OEX_FPU_DIV0)
14464 printf ("%sDIV0", first ? "" : "|"), first = FALSE;
14465 if (mask & OEX_FPU_INVAL)
14466 printf ("%sINVAL", first ? "" : "|");
14467 }
14468 else
14469 fputs ("0", stdout);
14470 }
14471
14472 /* Display's the value of TAG at location P. If TAG is
14473 greater than 0 it is assumed to be an unknown tag, and
14474 a message is printed to this effect. Otherwise it is
14475 assumed that a message has already been printed.
14476
14477 If the bottom bit of TAG is set it assumed to have a
14478 string value, otherwise it is assumed to have an integer
14479 value.
14480
14481 Returns an updated P pointing to the first unread byte
14482 beyond the end of TAG's value.
14483
14484 Reads at or beyond END will not be made. */
14485
14486 static unsigned char *
14487 display_tag_value (signed int tag,
14488 unsigned char * p,
14489 const unsigned char * const end)
14490 {
14491 unsigned long val;
14492
14493 if (tag > 0)
14494 printf (" Tag_unknown_%d: ", tag);
14495
14496 if (p >= end)
14497 {
14498 warn (_("<corrupt tag>\n"));
14499 }
14500 else if (tag & 1)
14501 {
14502 /* PR 17531 file: 027-19978-0.004. */
14503 size_t maxlen = (end - p) - 1;
14504
14505 putchar ('"');
14506 if (maxlen > 0)
14507 {
14508 print_symbol ((int) maxlen, (const char *) p);
14509 p += strnlen ((char *) p, maxlen) + 1;
14510 }
14511 else
14512 {
14513 printf (_("<corrupt string tag>"));
14514 p = (unsigned char *) end;
14515 }
14516 printf ("\"\n");
14517 }
14518 else
14519 {
14520 READ_ULEB (val, p, end);
14521 printf ("%ld (0x%lx)\n", val, val);
14522 }
14523
14524 assert (p <= end);
14525 return p;
14526 }
14527
14528 /* ARC ABI attributes section. */
14529
14530 static unsigned char *
14531 display_arc_attribute (unsigned char * p,
14532 const unsigned char * const end)
14533 {
14534 unsigned int tag;
14535 unsigned int val;
14536
14537 READ_ULEB (tag, p, end);
14538
14539 switch (tag)
14540 {
14541 case Tag_ARC_PCS_config:
14542 READ_ULEB (val, p, end);
14543 printf (" Tag_ARC_PCS_config: ");
14544 switch (val)
14545 {
14546 case 0:
14547 printf (_("Absent/Non standard\n"));
14548 break;
14549 case 1:
14550 printf (_("Bare metal/mwdt\n"));
14551 break;
14552 case 2:
14553 printf (_("Bare metal/newlib\n"));
14554 break;
14555 case 3:
14556 printf (_("Linux/uclibc\n"));
14557 break;
14558 case 4:
14559 printf (_("Linux/glibc\n"));
14560 break;
14561 default:
14562 printf (_("Unknown\n"));
14563 break;
14564 }
14565 break;
14566
14567 case Tag_ARC_CPU_base:
14568 READ_ULEB (val, p, end);
14569 printf (" Tag_ARC_CPU_base: ");
14570 switch (val)
14571 {
14572 default:
14573 case TAG_CPU_NONE:
14574 printf (_("Absent\n"));
14575 break;
14576 case TAG_CPU_ARC6xx:
14577 printf ("ARC6xx\n");
14578 break;
14579 case TAG_CPU_ARC7xx:
14580 printf ("ARC7xx\n");
14581 break;
14582 case TAG_CPU_ARCEM:
14583 printf ("ARCEM\n");
14584 break;
14585 case TAG_CPU_ARCHS:
14586 printf ("ARCHS\n");
14587 break;
14588 }
14589 break;
14590
14591 case Tag_ARC_CPU_variation:
14592 READ_ULEB (val, p, end);
14593 printf (" Tag_ARC_CPU_variation: ");
14594 switch (val)
14595 {
14596 default:
14597 if (val > 0 && val < 16)
14598 printf ("Core%d\n", val);
14599 else
14600 printf ("Unknown\n");
14601 break;
14602
14603 case 0:
14604 printf (_("Absent\n"));
14605 break;
14606 }
14607 break;
14608
14609 case Tag_ARC_CPU_name:
14610 printf (" Tag_ARC_CPU_name: ");
14611 p = display_tag_value (-1, p, end);
14612 break;
14613
14614 case Tag_ARC_ABI_rf16:
14615 READ_ULEB (val, p, end);
14616 printf (" Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
14617 break;
14618
14619 case Tag_ARC_ABI_osver:
14620 READ_ULEB (val, p, end);
14621 printf (" Tag_ARC_ABI_osver: v%d\n", val);
14622 break;
14623
14624 case Tag_ARC_ABI_pic:
14625 case Tag_ARC_ABI_sda:
14626 READ_ULEB (val, p, end);
14627 printf (tag == Tag_ARC_ABI_sda ? " Tag_ARC_ABI_sda: "
14628 : " Tag_ARC_ABI_pic: ");
14629 switch (val)
14630 {
14631 case 0:
14632 printf (_("Absent\n"));
14633 break;
14634 case 1:
14635 printf ("MWDT\n");
14636 break;
14637 case 2:
14638 printf ("GNU\n");
14639 break;
14640 default:
14641 printf (_("Unknown\n"));
14642 break;
14643 }
14644 break;
14645
14646 case Tag_ARC_ABI_tls:
14647 READ_ULEB (val, p, end);
14648 printf (" Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
14649 break;
14650
14651 case Tag_ARC_ABI_enumsize:
14652 READ_ULEB (val, p, end);
14653 printf (" Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
14654 _("smallest"));
14655 break;
14656
14657 case Tag_ARC_ABI_exceptions:
14658 READ_ULEB (val, p, end);
14659 printf (" Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
14660 : _("default"));
14661 break;
14662
14663 case Tag_ARC_ABI_double_size:
14664 READ_ULEB (val, p, end);
14665 printf (" Tag_ARC_ABI_double_size: %d\n", val);
14666 break;
14667
14668 case Tag_ARC_ISA_config:
14669 printf (" Tag_ARC_ISA_config: ");
14670 p = display_tag_value (-1, p, end);
14671 break;
14672
14673 case Tag_ARC_ISA_apex:
14674 printf (" Tag_ARC_ISA_apex: ");
14675 p = display_tag_value (-1, p, end);
14676 break;
14677
14678 case Tag_ARC_ISA_mpy_option:
14679 READ_ULEB (val, p, end);
14680 printf (" Tag_ARC_ISA_mpy_option: %d\n", val);
14681 break;
14682
14683 case Tag_ARC_ATR_version:
14684 READ_ULEB (val, p, end);
14685 printf (" Tag_ARC_ATR_version: %d\n", val);
14686 break;
14687
14688 default:
14689 return display_tag_value (tag & 1, p, end);
14690 }
14691
14692 return p;
14693 }
14694
14695 /* ARM EABI attributes section. */
14696 typedef struct
14697 {
14698 unsigned int tag;
14699 const char * name;
14700 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
14701 unsigned int type;
14702 const char ** table;
14703 } arm_attr_public_tag;
14704
14705 static const char * arm_attr_tag_CPU_arch[] =
14706 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14707 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14708 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
14709 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
14710 static const char * arm_attr_tag_THUMB_ISA_use[] =
14711 {"No", "Thumb-1", "Thumb-2", "Yes"};
14712 static const char * arm_attr_tag_FP_arch[] =
14713 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14714 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14715 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
14716 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
14717 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14718 "NEON for ARMv8.1"};
14719 static const char * arm_attr_tag_PCS_config[] =
14720 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14721 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14722 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
14723 {"V6", "SB", "TLS", "Unused"};
14724 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
14725 {"Absolute", "PC-relative", "SB-relative", "None"};
14726 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
14727 {"Absolute", "PC-relative", "None"};
14728 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
14729 {"None", "direct", "GOT-indirect"};
14730 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
14731 {"None", "??? 1", "2", "??? 3", "4"};
14732 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
14733 static const char * arm_attr_tag_ABI_FP_denormal[] =
14734 {"Unused", "Needed", "Sign only"};
14735 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
14736 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
14737 static const char * arm_attr_tag_ABI_FP_number_model[] =
14738 {"Unused", "Finite", "RTABI", "IEEE 754"};
14739 static const char * arm_attr_tag_ABI_enum_size[] =
14740 {"Unused", "small", "int", "forced to int"};
14741 static const char * arm_attr_tag_ABI_HardFP_use[] =
14742 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14743 static const char * arm_attr_tag_ABI_VFP_args[] =
14744 {"AAPCS", "VFP registers", "custom", "compatible"};
14745 static const char * arm_attr_tag_ABI_WMMX_args[] =
14746 {"AAPCS", "WMMX registers", "custom"};
14747 static const char * arm_attr_tag_ABI_optimization_goals[] =
14748 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14749 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14750 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
14751 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14752 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14753 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
14754 static const char * arm_attr_tag_FP_HP_extension[] =
14755 {"Not Allowed", "Allowed"};
14756 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
14757 {"None", "IEEE 754", "Alternative Format"};
14758 static const char * arm_attr_tag_DSP_extension[] =
14759 {"Follow architecture", "Allowed"};
14760 static const char * arm_attr_tag_MPextension_use[] =
14761 {"Not Allowed", "Allowed"};
14762 static const char * arm_attr_tag_DIV_use[] =
14763 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14764 "Allowed in v7-A with integer division extension"};
14765 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
14766 static const char * arm_attr_tag_Virtualization_use[] =
14767 {"Not Allowed", "TrustZone", "Virtualization Extensions",
14768 "TrustZone and Virtualization Extensions"};
14769 static const char * arm_attr_tag_MPextension_use_legacy[] =
14770 {"Not Allowed", "Allowed"};
14771
14772 static const char * arm_attr_tag_MVE_arch[] =
14773 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
14774
14775 #define LOOKUP(id, name) \
14776 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14777 static arm_attr_public_tag arm_attr_public_tags[] =
14778 {
14779 {4, "CPU_raw_name", 1, NULL},
14780 {5, "CPU_name", 1, NULL},
14781 LOOKUP(6, CPU_arch),
14782 {7, "CPU_arch_profile", 0, NULL},
14783 LOOKUP(8, ARM_ISA_use),
14784 LOOKUP(9, THUMB_ISA_use),
14785 LOOKUP(10, FP_arch),
14786 LOOKUP(11, WMMX_arch),
14787 LOOKUP(12, Advanced_SIMD_arch),
14788 LOOKUP(13, PCS_config),
14789 LOOKUP(14, ABI_PCS_R9_use),
14790 LOOKUP(15, ABI_PCS_RW_data),
14791 LOOKUP(16, ABI_PCS_RO_data),
14792 LOOKUP(17, ABI_PCS_GOT_use),
14793 LOOKUP(18, ABI_PCS_wchar_t),
14794 LOOKUP(19, ABI_FP_rounding),
14795 LOOKUP(20, ABI_FP_denormal),
14796 LOOKUP(21, ABI_FP_exceptions),
14797 LOOKUP(22, ABI_FP_user_exceptions),
14798 LOOKUP(23, ABI_FP_number_model),
14799 {24, "ABI_align_needed", 0, NULL},
14800 {25, "ABI_align_preserved", 0, NULL},
14801 LOOKUP(26, ABI_enum_size),
14802 LOOKUP(27, ABI_HardFP_use),
14803 LOOKUP(28, ABI_VFP_args),
14804 LOOKUP(29, ABI_WMMX_args),
14805 LOOKUP(30, ABI_optimization_goals),
14806 LOOKUP(31, ABI_FP_optimization_goals),
14807 {32, "compatibility", 0, NULL},
14808 LOOKUP(34, CPU_unaligned_access),
14809 LOOKUP(36, FP_HP_extension),
14810 LOOKUP(38, ABI_FP_16bit_format),
14811 LOOKUP(42, MPextension_use),
14812 LOOKUP(44, DIV_use),
14813 LOOKUP(46, DSP_extension),
14814 LOOKUP(48, MVE_arch),
14815 {64, "nodefaults", 0, NULL},
14816 {65, "also_compatible_with", 0, NULL},
14817 LOOKUP(66, T2EE_use),
14818 {67, "conformance", 1, NULL},
14819 LOOKUP(68, Virtualization_use),
14820 LOOKUP(70, MPextension_use_legacy)
14821 };
14822 #undef LOOKUP
14823
14824 static unsigned char *
14825 display_arm_attribute (unsigned char * p,
14826 const unsigned char * const end)
14827 {
14828 unsigned int tag;
14829 unsigned int val;
14830 arm_attr_public_tag * attr;
14831 unsigned i;
14832 unsigned int type;
14833
14834 READ_ULEB (tag, p, end);
14835 attr = NULL;
14836 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
14837 {
14838 if (arm_attr_public_tags[i].tag == tag)
14839 {
14840 attr = &arm_attr_public_tags[i];
14841 break;
14842 }
14843 }
14844
14845 if (attr)
14846 {
14847 printf (" Tag_%s: ", attr->name);
14848 switch (attr->type)
14849 {
14850 case 0:
14851 switch (tag)
14852 {
14853 case 7: /* Tag_CPU_arch_profile. */
14854 READ_ULEB (val, p, end);
14855 switch (val)
14856 {
14857 case 0: printf (_("None\n")); break;
14858 case 'A': printf (_("Application\n")); break;
14859 case 'R': printf (_("Realtime\n")); break;
14860 case 'M': printf (_("Microcontroller\n")); break;
14861 case 'S': printf (_("Application or Realtime\n")); break;
14862 default: printf ("??? (%d)\n", val); break;
14863 }
14864 break;
14865
14866 case 24: /* Tag_align_needed. */
14867 READ_ULEB (val, p, end);
14868 switch (val)
14869 {
14870 case 0: printf (_("None\n")); break;
14871 case 1: printf (_("8-byte\n")); break;
14872 case 2: printf (_("4-byte\n")); break;
14873 case 3: printf ("??? 3\n"); break;
14874 default:
14875 if (val <= 12)
14876 printf (_("8-byte and up to %d-byte extended\n"),
14877 1 << val);
14878 else
14879 printf ("??? (%d)\n", val);
14880 break;
14881 }
14882 break;
14883
14884 case 25: /* Tag_align_preserved. */
14885 READ_ULEB (val, p, end);
14886 switch (val)
14887 {
14888 case 0: printf (_("None\n")); break;
14889 case 1: printf (_("8-byte, except leaf SP\n")); break;
14890 case 2: printf (_("8-byte\n")); break;
14891 case 3: printf ("??? 3\n"); break;
14892 default:
14893 if (val <= 12)
14894 printf (_("8-byte and up to %d-byte extended\n"),
14895 1 << val);
14896 else
14897 printf ("??? (%d)\n", val);
14898 break;
14899 }
14900 break;
14901
14902 case 32: /* Tag_compatibility. */
14903 {
14904 READ_ULEB (val, p, end);
14905 printf (_("flag = %d, vendor = "), val);
14906 if (p < end - 1)
14907 {
14908 size_t maxlen = (end - p) - 1;
14909
14910 print_symbol ((int) maxlen, (const char *) p);
14911 p += strnlen ((char *) p, maxlen) + 1;
14912 }
14913 else
14914 {
14915 printf (_("<corrupt>"));
14916 p = (unsigned char *) end;
14917 }
14918 putchar ('\n');
14919 }
14920 break;
14921
14922 case 64: /* Tag_nodefaults. */
14923 /* PR 17531: file: 001-505008-0.01. */
14924 if (p < end)
14925 p++;
14926 printf (_("True\n"));
14927 break;
14928
14929 case 65: /* Tag_also_compatible_with. */
14930 READ_ULEB (val, p, end);
14931 if (val == 6 /* Tag_CPU_arch. */)
14932 {
14933 READ_ULEB (val, p, end);
14934 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
14935 printf ("??? (%d)\n", val);
14936 else
14937 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
14938 }
14939 else
14940 printf ("???\n");
14941 while (p < end && *(p++) != '\0' /* NUL terminator. */)
14942 ;
14943 break;
14944
14945 default:
14946 printf (_("<unknown: %d>\n"), tag);
14947 break;
14948 }
14949 return p;
14950
14951 case 1:
14952 return display_tag_value (-1, p, end);
14953 case 2:
14954 return display_tag_value (0, p, end);
14955
14956 default:
14957 assert (attr->type & 0x80);
14958 READ_ULEB (val, p, end);
14959 type = attr->type & 0x7f;
14960 if (val >= type)
14961 printf ("??? (%d)\n", val);
14962 else
14963 printf ("%s\n", attr->table[val]);
14964 return p;
14965 }
14966 }
14967
14968 return display_tag_value (tag, p, end);
14969 }
14970
14971 static unsigned char *
14972 display_gnu_attribute (unsigned char * p,
14973 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
14974 const unsigned char * const end)
14975 {
14976 unsigned int tag;
14977 unsigned int val;
14978
14979 READ_ULEB (tag, p, end);
14980
14981 /* Tag_compatibility is the only generic GNU attribute defined at
14982 present. */
14983 if (tag == 32)
14984 {
14985 READ_ULEB (val, p, end);
14986
14987 printf (_("flag = %d, vendor = "), val);
14988 if (p == end)
14989 {
14990 printf (_("<corrupt>\n"));
14991 warn (_("corrupt vendor attribute\n"));
14992 }
14993 else
14994 {
14995 if (p < end - 1)
14996 {
14997 size_t maxlen = (end - p) - 1;
14998
14999 print_symbol ((int) maxlen, (const char *) p);
15000 p += strnlen ((char *) p, maxlen) + 1;
15001 }
15002 else
15003 {
15004 printf (_("<corrupt>"));
15005 p = (unsigned char *) end;
15006 }
15007 putchar ('\n');
15008 }
15009 return p;
15010 }
15011
15012 if ((tag & 2) == 0 && display_proc_gnu_attribute)
15013 return display_proc_gnu_attribute (p, tag, end);
15014
15015 return display_tag_value (tag, p, end);
15016 }
15017
15018 static unsigned char *
15019 display_power_gnu_attribute (unsigned char * p,
15020 unsigned int tag,
15021 const unsigned char * const end)
15022 {
15023 unsigned int val;
15024
15025 if (tag == Tag_GNU_Power_ABI_FP)
15026 {
15027 printf (" Tag_GNU_Power_ABI_FP: ");
15028 if (p == end)
15029 {
15030 printf (_("<corrupt>\n"));
15031 return p;
15032 }
15033 READ_ULEB (val, p, end);
15034
15035 if (val > 15)
15036 printf ("(%#x), ", val);
15037
15038 switch (val & 3)
15039 {
15040 case 0:
15041 printf (_("unspecified hard/soft float, "));
15042 break;
15043 case 1:
15044 printf (_("hard float, "));
15045 break;
15046 case 2:
15047 printf (_("soft float, "));
15048 break;
15049 case 3:
15050 printf (_("single-precision hard float, "));
15051 break;
15052 }
15053
15054 switch (val & 0xC)
15055 {
15056 case 0:
15057 printf (_("unspecified long double\n"));
15058 break;
15059 case 4:
15060 printf (_("128-bit IBM long double\n"));
15061 break;
15062 case 8:
15063 printf (_("64-bit long double\n"));
15064 break;
15065 case 12:
15066 printf (_("128-bit IEEE long double\n"));
15067 break;
15068 }
15069 return p;
15070 }
15071
15072 if (tag == Tag_GNU_Power_ABI_Vector)
15073 {
15074 printf (" Tag_GNU_Power_ABI_Vector: ");
15075 if (p == end)
15076 {
15077 printf (_("<corrupt>\n"));
15078 return p;
15079 }
15080 READ_ULEB (val, p, end);
15081
15082 if (val > 3)
15083 printf ("(%#x), ", val);
15084
15085 switch (val & 3)
15086 {
15087 case 0:
15088 printf (_("unspecified\n"));
15089 break;
15090 case 1:
15091 printf (_("generic\n"));
15092 break;
15093 case 2:
15094 printf ("AltiVec\n");
15095 break;
15096 case 3:
15097 printf ("SPE\n");
15098 break;
15099 }
15100 return p;
15101 }
15102
15103 if (tag == Tag_GNU_Power_ABI_Struct_Return)
15104 {
15105 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
15106 if (p == end)
15107 {
15108 printf (_("<corrupt>\n"));
15109 return p;
15110 }
15111 READ_ULEB (val, p, end);
15112
15113 if (val > 2)
15114 printf ("(%#x), ", val);
15115
15116 switch (val & 3)
15117 {
15118 case 0:
15119 printf (_("unspecified\n"));
15120 break;
15121 case 1:
15122 printf ("r3/r4\n");
15123 break;
15124 case 2:
15125 printf (_("memory\n"));
15126 break;
15127 case 3:
15128 printf ("???\n");
15129 break;
15130 }
15131 return p;
15132 }
15133
15134 return display_tag_value (tag & 1, p, end);
15135 }
15136
15137 static unsigned char *
15138 display_s390_gnu_attribute (unsigned char * p,
15139 unsigned int tag,
15140 const unsigned char * const end)
15141 {
15142 unsigned int val;
15143
15144 if (tag == Tag_GNU_S390_ABI_Vector)
15145 {
15146 printf (" Tag_GNU_S390_ABI_Vector: ");
15147 READ_ULEB (val, p, end);
15148
15149 switch (val)
15150 {
15151 case 0:
15152 printf (_("any\n"));
15153 break;
15154 case 1:
15155 printf (_("software\n"));
15156 break;
15157 case 2:
15158 printf (_("hardware\n"));
15159 break;
15160 default:
15161 printf ("??? (%d)\n", val);
15162 break;
15163 }
15164 return p;
15165 }
15166
15167 return display_tag_value (tag & 1, p, end);
15168 }
15169
15170 static void
15171 display_sparc_hwcaps (unsigned int mask)
15172 {
15173 if (mask)
15174 {
15175 bfd_boolean first = TRUE;
15176
15177 if (mask & ELF_SPARC_HWCAP_MUL32)
15178 fputs ("mul32", stdout), first = FALSE;
15179 if (mask & ELF_SPARC_HWCAP_DIV32)
15180 printf ("%sdiv32", first ? "" : "|"), first = FALSE;
15181 if (mask & ELF_SPARC_HWCAP_FSMULD)
15182 printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
15183 if (mask & ELF_SPARC_HWCAP_V8PLUS)
15184 printf ("%sv8plus", first ? "" : "|"), first = FALSE;
15185 if (mask & ELF_SPARC_HWCAP_POPC)
15186 printf ("%spopc", first ? "" : "|"), first = FALSE;
15187 if (mask & ELF_SPARC_HWCAP_VIS)
15188 printf ("%svis", first ? "" : "|"), first = FALSE;
15189 if (mask & ELF_SPARC_HWCAP_VIS2)
15190 printf ("%svis2", first ? "" : "|"), first = FALSE;
15191 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
15192 printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
15193 if (mask & ELF_SPARC_HWCAP_FMAF)
15194 printf ("%sfmaf", first ? "" : "|"), first = FALSE;
15195 if (mask & ELF_SPARC_HWCAP_VIS3)
15196 printf ("%svis3", first ? "" : "|"), first = FALSE;
15197 if (mask & ELF_SPARC_HWCAP_HPC)
15198 printf ("%shpc", first ? "" : "|"), first = FALSE;
15199 if (mask & ELF_SPARC_HWCAP_RANDOM)
15200 printf ("%srandom", first ? "" : "|"), first = FALSE;
15201 if (mask & ELF_SPARC_HWCAP_TRANS)
15202 printf ("%strans", first ? "" : "|"), first = FALSE;
15203 if (mask & ELF_SPARC_HWCAP_FJFMAU)
15204 printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
15205 if (mask & ELF_SPARC_HWCAP_IMA)
15206 printf ("%sima", first ? "" : "|"), first = FALSE;
15207 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
15208 printf ("%scspare", first ? "" : "|"), first = FALSE;
15209 }
15210 else
15211 fputc ('0', stdout);
15212 fputc ('\n', stdout);
15213 }
15214
15215 static void
15216 display_sparc_hwcaps2 (unsigned int mask)
15217 {
15218 if (mask)
15219 {
15220 bfd_boolean first = TRUE;
15221
15222 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
15223 fputs ("fjathplus", stdout), first = FALSE;
15224 if (mask & ELF_SPARC_HWCAP2_VIS3B)
15225 printf ("%svis3b", first ? "" : "|"), first = FALSE;
15226 if (mask & ELF_SPARC_HWCAP2_ADP)
15227 printf ("%sadp", first ? "" : "|"), first = FALSE;
15228 if (mask & ELF_SPARC_HWCAP2_SPARC5)
15229 printf ("%ssparc5", first ? "" : "|"), first = FALSE;
15230 if (mask & ELF_SPARC_HWCAP2_MWAIT)
15231 printf ("%smwait", first ? "" : "|"), first = FALSE;
15232 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
15233 printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
15234 if (mask & ELF_SPARC_HWCAP2_XMONT)
15235 printf ("%sxmont2", first ? "" : "|"), first = FALSE;
15236 if (mask & ELF_SPARC_HWCAP2_NSEC)
15237 printf ("%snsec", first ? "" : "|"), first = FALSE;
15238 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
15239 printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
15240 if (mask & ELF_SPARC_HWCAP2_FJDES)
15241 printf ("%sfjdes", first ? "" : "|"), first = FALSE;
15242 if (mask & ELF_SPARC_HWCAP2_FJAES)
15243 printf ("%sfjaes", first ? "" : "|"), first = FALSE;
15244 }
15245 else
15246 fputc ('0', stdout);
15247 fputc ('\n', stdout);
15248 }
15249
15250 static unsigned char *
15251 display_sparc_gnu_attribute (unsigned char * p,
15252 unsigned int tag,
15253 const unsigned char * const end)
15254 {
15255 unsigned int val;
15256
15257 if (tag == Tag_GNU_Sparc_HWCAPS)
15258 {
15259 READ_ULEB (val, p, end);
15260 printf (" Tag_GNU_Sparc_HWCAPS: ");
15261 display_sparc_hwcaps (val);
15262 return p;
15263 }
15264 if (tag == Tag_GNU_Sparc_HWCAPS2)
15265 {
15266 READ_ULEB (val, p, end);
15267 printf (" Tag_GNU_Sparc_HWCAPS2: ");
15268 display_sparc_hwcaps2 (val);
15269 return p;
15270 }
15271
15272 return display_tag_value (tag, p, end);
15273 }
15274
15275 static void
15276 print_mips_fp_abi_value (unsigned int val)
15277 {
15278 switch (val)
15279 {
15280 case Val_GNU_MIPS_ABI_FP_ANY:
15281 printf (_("Hard or soft float\n"));
15282 break;
15283 case Val_GNU_MIPS_ABI_FP_DOUBLE:
15284 printf (_("Hard float (double precision)\n"));
15285 break;
15286 case Val_GNU_MIPS_ABI_FP_SINGLE:
15287 printf (_("Hard float (single precision)\n"));
15288 break;
15289 case Val_GNU_MIPS_ABI_FP_SOFT:
15290 printf (_("Soft float\n"));
15291 break;
15292 case Val_GNU_MIPS_ABI_FP_OLD_64:
15293 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15294 break;
15295 case Val_GNU_MIPS_ABI_FP_XX:
15296 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15297 break;
15298 case Val_GNU_MIPS_ABI_FP_64:
15299 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15300 break;
15301 case Val_GNU_MIPS_ABI_FP_64A:
15302 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15303 break;
15304 case Val_GNU_MIPS_ABI_FP_NAN2008:
15305 printf (_("NaN 2008 compatibility\n"));
15306 break;
15307 default:
15308 printf ("??? (%d)\n", val);
15309 break;
15310 }
15311 }
15312
15313 static unsigned char *
15314 display_mips_gnu_attribute (unsigned char * p,
15315 unsigned int tag,
15316 const unsigned char * const end)
15317 {
15318 if (tag == Tag_GNU_MIPS_ABI_FP)
15319 {
15320 unsigned int val;
15321
15322 printf (" Tag_GNU_MIPS_ABI_FP: ");
15323 READ_ULEB (val, p, end);
15324 print_mips_fp_abi_value (val);
15325 return p;
15326 }
15327
15328 if (tag == Tag_GNU_MIPS_ABI_MSA)
15329 {
15330 unsigned int val;
15331
15332 printf (" Tag_GNU_MIPS_ABI_MSA: ");
15333 READ_ULEB (val, p, end);
15334
15335 switch (val)
15336 {
15337 case Val_GNU_MIPS_ABI_MSA_ANY:
15338 printf (_("Any MSA or not\n"));
15339 break;
15340 case Val_GNU_MIPS_ABI_MSA_128:
15341 printf (_("128-bit MSA\n"));
15342 break;
15343 default:
15344 printf ("??? (%d)\n", val);
15345 break;
15346 }
15347 return p;
15348 }
15349
15350 return display_tag_value (tag & 1, p, end);
15351 }
15352
15353 static unsigned char *
15354 display_tic6x_attribute (unsigned char * p,
15355 const unsigned char * const end)
15356 {
15357 unsigned int tag;
15358 unsigned int val;
15359
15360 READ_ULEB (tag, p, end);
15361
15362 switch (tag)
15363 {
15364 case Tag_ISA:
15365 printf (" Tag_ISA: ");
15366 READ_ULEB (val, p, end);
15367
15368 switch (val)
15369 {
15370 case C6XABI_Tag_ISA_none:
15371 printf (_("None\n"));
15372 break;
15373 case C6XABI_Tag_ISA_C62X:
15374 printf ("C62x\n");
15375 break;
15376 case C6XABI_Tag_ISA_C67X:
15377 printf ("C67x\n");
15378 break;
15379 case C6XABI_Tag_ISA_C67XP:
15380 printf ("C67x+\n");
15381 break;
15382 case C6XABI_Tag_ISA_C64X:
15383 printf ("C64x\n");
15384 break;
15385 case C6XABI_Tag_ISA_C64XP:
15386 printf ("C64x+\n");
15387 break;
15388 case C6XABI_Tag_ISA_C674X:
15389 printf ("C674x\n");
15390 break;
15391 default:
15392 printf ("??? (%d)\n", val);
15393 break;
15394 }
15395 return p;
15396
15397 case Tag_ABI_wchar_t:
15398 printf (" Tag_ABI_wchar_t: ");
15399 READ_ULEB (val, p, end);
15400 switch (val)
15401 {
15402 case 0:
15403 printf (_("Not used\n"));
15404 break;
15405 case 1:
15406 printf (_("2 bytes\n"));
15407 break;
15408 case 2:
15409 printf (_("4 bytes\n"));
15410 break;
15411 default:
15412 printf ("??? (%d)\n", val);
15413 break;
15414 }
15415 return p;
15416
15417 case Tag_ABI_stack_align_needed:
15418 printf (" Tag_ABI_stack_align_needed: ");
15419 READ_ULEB (val, p, end);
15420 switch (val)
15421 {
15422 case 0:
15423 printf (_("8-byte\n"));
15424 break;
15425 case 1:
15426 printf (_("16-byte\n"));
15427 break;
15428 default:
15429 printf ("??? (%d)\n", val);
15430 break;
15431 }
15432 return p;
15433
15434 case Tag_ABI_stack_align_preserved:
15435 READ_ULEB (val, p, end);
15436 printf (" Tag_ABI_stack_align_preserved: ");
15437 switch (val)
15438 {
15439 case 0:
15440 printf (_("8-byte\n"));
15441 break;
15442 case 1:
15443 printf (_("16-byte\n"));
15444 break;
15445 default:
15446 printf ("??? (%d)\n", val);
15447 break;
15448 }
15449 return p;
15450
15451 case Tag_ABI_DSBT:
15452 READ_ULEB (val, p, end);
15453 printf (" Tag_ABI_DSBT: ");
15454 switch (val)
15455 {
15456 case 0:
15457 printf (_("DSBT addressing not used\n"));
15458 break;
15459 case 1:
15460 printf (_("DSBT addressing used\n"));
15461 break;
15462 default:
15463 printf ("??? (%d)\n", val);
15464 break;
15465 }
15466 return p;
15467
15468 case Tag_ABI_PID:
15469 READ_ULEB (val, p, end);
15470 printf (" Tag_ABI_PID: ");
15471 switch (val)
15472 {
15473 case 0:
15474 printf (_("Data addressing position-dependent\n"));
15475 break;
15476 case 1:
15477 printf (_("Data addressing position-independent, GOT near DP\n"));
15478 break;
15479 case 2:
15480 printf (_("Data addressing position-independent, GOT far from DP\n"));
15481 break;
15482 default:
15483 printf ("??? (%d)\n", val);
15484 break;
15485 }
15486 return p;
15487
15488 case Tag_ABI_PIC:
15489 READ_ULEB (val, p, end);
15490 printf (" Tag_ABI_PIC: ");
15491 switch (val)
15492 {
15493 case 0:
15494 printf (_("Code addressing position-dependent\n"));
15495 break;
15496 case 1:
15497 printf (_("Code addressing position-independent\n"));
15498 break;
15499 default:
15500 printf ("??? (%d)\n", val);
15501 break;
15502 }
15503 return p;
15504
15505 case Tag_ABI_array_object_alignment:
15506 READ_ULEB (val, p, end);
15507 printf (" Tag_ABI_array_object_alignment: ");
15508 switch (val)
15509 {
15510 case 0:
15511 printf (_("8-byte\n"));
15512 break;
15513 case 1:
15514 printf (_("4-byte\n"));
15515 break;
15516 case 2:
15517 printf (_("16-byte\n"));
15518 break;
15519 default:
15520 printf ("??? (%d)\n", val);
15521 break;
15522 }
15523 return p;
15524
15525 case Tag_ABI_array_object_align_expected:
15526 READ_ULEB (val, p, end);
15527 printf (" Tag_ABI_array_object_align_expected: ");
15528 switch (val)
15529 {
15530 case 0:
15531 printf (_("8-byte\n"));
15532 break;
15533 case 1:
15534 printf (_("4-byte\n"));
15535 break;
15536 case 2:
15537 printf (_("16-byte\n"));
15538 break;
15539 default:
15540 printf ("??? (%d)\n", val);
15541 break;
15542 }
15543 return p;
15544
15545 case Tag_ABI_compatibility:
15546 {
15547 READ_ULEB (val, p, end);
15548 printf (" Tag_ABI_compatibility: ");
15549 printf (_("flag = %d, vendor = "), val);
15550 if (p < end - 1)
15551 {
15552 size_t maxlen = (end - p) - 1;
15553
15554 print_symbol ((int) maxlen, (const char *) p);
15555 p += strnlen ((char *) p, maxlen) + 1;
15556 }
15557 else
15558 {
15559 printf (_("<corrupt>"));
15560 p = (unsigned char *) end;
15561 }
15562 putchar ('\n');
15563 return p;
15564 }
15565
15566 case Tag_ABI_conformance:
15567 {
15568 printf (" Tag_ABI_conformance: \"");
15569 if (p < end - 1)
15570 {
15571 size_t maxlen = (end - p) - 1;
15572
15573 print_symbol ((int) maxlen, (const char *) p);
15574 p += strnlen ((char *) p, maxlen) + 1;
15575 }
15576 else
15577 {
15578 printf (_("<corrupt>"));
15579 p = (unsigned char *) end;
15580 }
15581 printf ("\"\n");
15582 return p;
15583 }
15584 }
15585
15586 return display_tag_value (tag, p, end);
15587 }
15588
15589 static void
15590 display_raw_attribute (unsigned char * p, unsigned char const * const end)
15591 {
15592 unsigned long addr = 0;
15593 size_t bytes = end - p;
15594
15595 assert (end >= p);
15596 while (bytes)
15597 {
15598 int j;
15599 int k;
15600 int lbytes = (bytes > 16 ? 16 : bytes);
15601
15602 printf (" 0x%8.8lx ", addr);
15603
15604 for (j = 0; j < 16; j++)
15605 {
15606 if (j < lbytes)
15607 printf ("%2.2x", p[j]);
15608 else
15609 printf (" ");
15610
15611 if ((j & 3) == 3)
15612 printf (" ");
15613 }
15614
15615 for (j = 0; j < lbytes; j++)
15616 {
15617 k = p[j];
15618 if (k >= ' ' && k < 0x7f)
15619 printf ("%c", k);
15620 else
15621 printf (".");
15622 }
15623
15624 putchar ('\n');
15625
15626 p += lbytes;
15627 bytes -= lbytes;
15628 addr += lbytes;
15629 }
15630
15631 putchar ('\n');
15632 }
15633
15634 static unsigned char *
15635 display_msp430x_attribute (unsigned char * p,
15636 const unsigned char * const end)
15637 {
15638 unsigned int val;
15639 unsigned int tag;
15640
15641 READ_ULEB (tag, p, end);
15642
15643 switch (tag)
15644 {
15645 case OFBA_MSPABI_Tag_ISA:
15646 printf (" Tag_ISA: ");
15647 READ_ULEB (val, p, end);
15648 switch (val)
15649 {
15650 case 0: printf (_("None\n")); break;
15651 case 1: printf (_("MSP430\n")); break;
15652 case 2: printf (_("MSP430X\n")); break;
15653 default: printf ("??? (%d)\n", val); break;
15654 }
15655 break;
15656
15657 case OFBA_MSPABI_Tag_Code_Model:
15658 printf (" Tag_Code_Model: ");
15659 READ_ULEB (val, p, end);
15660 switch (val)
15661 {
15662 case 0: printf (_("None\n")); break;
15663 case 1: printf (_("Small\n")); break;
15664 case 2: printf (_("Large\n")); break;
15665 default: printf ("??? (%d)\n", val); break;
15666 }
15667 break;
15668
15669 case OFBA_MSPABI_Tag_Data_Model:
15670 printf (" Tag_Data_Model: ");
15671 READ_ULEB (val, p, end);
15672 switch (val)
15673 {
15674 case 0: printf (_("None\n")); break;
15675 case 1: printf (_("Small\n")); break;
15676 case 2: printf (_("Large\n")); break;
15677 case 3: printf (_("Restricted Large\n")); break;
15678 default: printf ("??? (%d)\n", val); break;
15679 }
15680 break;
15681
15682 default:
15683 printf (_(" <unknown tag %d>: "), tag);
15684
15685 if (tag & 1)
15686 {
15687 putchar ('"');
15688 if (p < end - 1)
15689 {
15690 size_t maxlen = (end - p) - 1;
15691
15692 print_symbol ((int) maxlen, (const char *) p);
15693 p += strnlen ((char *) p, maxlen) + 1;
15694 }
15695 else
15696 {
15697 printf (_("<corrupt>"));
15698 p = (unsigned char *) end;
15699 }
15700 printf ("\"\n");
15701 }
15702 else
15703 {
15704 READ_ULEB (val, p, end);
15705 printf ("%d (0x%x)\n", val, val);
15706 }
15707 break;
15708 }
15709
15710 assert (p <= end);
15711 return p;
15712 }
15713
15714 static unsigned char *
15715 display_msp430_gnu_attribute (unsigned char * p,
15716 unsigned int tag,
15717 const unsigned char * const end)
15718 {
15719 if (tag == Tag_GNU_MSP430_Data_Region)
15720 {
15721 unsigned int val;
15722
15723 printf (" Tag_GNU_MSP430_Data_Region: ");
15724 READ_ULEB (val, p, end);
15725
15726 switch (val)
15727 {
15728 case Val_GNU_MSP430_Data_Region_Any:
15729 printf (_("Any Region\n"));
15730 break;
15731 case Val_GNU_MSP430_Data_Region_Lower:
15732 printf (_("Lower Region Only\n"));
15733 break;
15734 default:
15735 printf ("??? (%u)\n", val);
15736 }
15737 return p;
15738 }
15739 return display_tag_value (tag & 1, p, end);
15740 }
15741
15742 struct riscv_attr_tag_t {
15743 const char *name;
15744 unsigned int tag;
15745 };
15746
15747 static struct riscv_attr_tag_t riscv_attr_tag[] =
15748 {
15749 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
15750 T(arch),
15751 T(priv_spec),
15752 T(priv_spec_minor),
15753 T(priv_spec_revision),
15754 T(unaligned_access),
15755 T(stack_align),
15756 #undef T
15757 };
15758
15759 static unsigned char *
15760 display_riscv_attribute (unsigned char *p,
15761 const unsigned char * const end)
15762 {
15763 unsigned int val;
15764 unsigned int tag;
15765 struct riscv_attr_tag_t *attr = NULL;
15766 unsigned i;
15767
15768 READ_ULEB (tag, p, end);
15769
15770 /* Find the name of attribute. */
15771 for (i = 0; i < ARRAY_SIZE (riscv_attr_tag); i++)
15772 {
15773 if (riscv_attr_tag[i].tag == tag)
15774 {
15775 attr = &riscv_attr_tag[i];
15776 break;
15777 }
15778 }
15779
15780 if (attr)
15781 printf (" %s: ", attr->name);
15782 else
15783 return display_tag_value (tag, p, end);
15784
15785 switch (tag)
15786 {
15787 case Tag_RISCV_priv_spec:
15788 case Tag_RISCV_priv_spec_minor:
15789 case Tag_RISCV_priv_spec_revision:
15790 READ_ULEB (val, p, end);
15791 printf (_("%u\n"), val);
15792 break;
15793 case Tag_RISCV_unaligned_access:
15794 READ_ULEB (val, p, end);
15795 switch (val)
15796 {
15797 case 0:
15798 printf (_("No unaligned access\n"));
15799 break;
15800 case 1:
15801 printf (_("Unaligned access\n"));
15802 break;
15803 }
15804 break;
15805 case Tag_RISCV_stack_align:
15806 READ_ULEB (val, p, end);
15807 printf (_("%u-bytes\n"), val);
15808 break;
15809 case Tag_RISCV_arch:
15810 p = display_tag_value (-1, p, end);
15811 break;
15812 default:
15813 return display_tag_value (tag, p, end);
15814 }
15815
15816 return p;
15817 }
15818
15819 static bfd_boolean
15820 process_attributes (Filedata * filedata,
15821 const char * public_name,
15822 unsigned int proc_type,
15823 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
15824 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
15825 {
15826 Elf_Internal_Shdr * sect;
15827 unsigned i;
15828 bfd_boolean res = TRUE;
15829
15830 /* Find the section header so that we get the size. */
15831 for (i = 0, sect = filedata->section_headers;
15832 i < filedata->file_header.e_shnum;
15833 i++, sect++)
15834 {
15835 unsigned char * contents;
15836 unsigned char * p;
15837
15838 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
15839 continue;
15840
15841 contents = (unsigned char *) get_data (NULL, filedata, sect->sh_offset, 1,
15842 sect->sh_size, _("attributes"));
15843 if (contents == NULL)
15844 {
15845 res = FALSE;
15846 continue;
15847 }
15848
15849 p = contents;
15850 /* The first character is the version of the attributes.
15851 Currently only version 1, (aka 'A') is recognised here. */
15852 if (*p != 'A')
15853 {
15854 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
15855 res = FALSE;
15856 }
15857 else
15858 {
15859 bfd_vma section_len;
15860
15861 section_len = sect->sh_size - 1;
15862 p++;
15863
15864 while (section_len > 0)
15865 {
15866 bfd_vma attr_len;
15867 unsigned int namelen;
15868 bfd_boolean public_section;
15869 bfd_boolean gnu_section;
15870
15871 if (section_len <= 4)
15872 {
15873 error (_("Tag section ends prematurely\n"));
15874 res = FALSE;
15875 break;
15876 }
15877 attr_len = byte_get (p, 4);
15878 p += 4;
15879
15880 if (attr_len > section_len)
15881 {
15882 error (_("Bad attribute length (%u > %u)\n"),
15883 (unsigned) attr_len, (unsigned) section_len);
15884 attr_len = section_len;
15885 res = FALSE;
15886 }
15887 /* PR 17531: file: 001-101425-0.004 */
15888 else if (attr_len < 5)
15889 {
15890 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
15891 res = FALSE;
15892 break;
15893 }
15894
15895 section_len -= attr_len;
15896 attr_len -= 4;
15897
15898 namelen = strnlen ((char *) p, attr_len) + 1;
15899 if (namelen == 0 || namelen >= attr_len)
15900 {
15901 error (_("Corrupt attribute section name\n"));
15902 res = FALSE;
15903 break;
15904 }
15905
15906 printf (_("Attribute Section: "));
15907 print_symbol (INT_MAX, (const char *) p);
15908 putchar ('\n');
15909
15910 if (public_name && streq ((char *) p, public_name))
15911 public_section = TRUE;
15912 else
15913 public_section = FALSE;
15914
15915 if (streq ((char *) p, "gnu"))
15916 gnu_section = TRUE;
15917 else
15918 gnu_section = FALSE;
15919
15920 p += namelen;
15921 attr_len -= namelen;
15922
15923 while (attr_len > 0 && p < contents + sect->sh_size)
15924 {
15925 int tag;
15926 unsigned int val;
15927 bfd_vma size;
15928 unsigned char * end;
15929
15930 /* PR binutils/17531: Safe handling of corrupt files. */
15931 if (attr_len < 6)
15932 {
15933 error (_("Unused bytes at end of section\n"));
15934 res = FALSE;
15935 section_len = 0;
15936 break;
15937 }
15938
15939 tag = *(p++);
15940 size = byte_get (p, 4);
15941 if (size > attr_len)
15942 {
15943 error (_("Bad subsection length (%u > %u)\n"),
15944 (unsigned) size, (unsigned) attr_len);
15945 res = FALSE;
15946 size = attr_len;
15947 }
15948 /* PR binutils/17531: Safe handling of corrupt files. */
15949 if (size < 6)
15950 {
15951 error (_("Bad subsection length (%u < 6)\n"),
15952 (unsigned) size);
15953 res = FALSE;
15954 section_len = 0;
15955 break;
15956 }
15957
15958 attr_len -= size;
15959 end = p + size - 1;
15960 assert (end <= contents + sect->sh_size);
15961 p += 4;
15962
15963 switch (tag)
15964 {
15965 case 1:
15966 printf (_("File Attributes\n"));
15967 break;
15968 case 2:
15969 printf (_("Section Attributes:"));
15970 goto do_numlist;
15971 case 3:
15972 printf (_("Symbol Attributes:"));
15973 /* Fall through. */
15974 do_numlist:
15975 for (;;)
15976 {
15977 READ_ULEB (val, p, end);
15978 if (val == 0)
15979 break;
15980 printf (" %d", val);
15981 }
15982 printf ("\n");
15983 break;
15984 default:
15985 printf (_("Unknown tag: %d\n"), tag);
15986 public_section = FALSE;
15987 break;
15988 }
15989
15990 if (public_section && display_pub_attribute != NULL)
15991 {
15992 while (p < end)
15993 p = display_pub_attribute (p, end);
15994 assert (p == end);
15995 }
15996 else if (gnu_section && display_proc_gnu_attribute != NULL)
15997 {
15998 while (p < end)
15999 p = display_gnu_attribute (p,
16000 display_proc_gnu_attribute,
16001 end);
16002 assert (p == end);
16003 }
16004 else if (p < end)
16005 {
16006 printf (_(" Unknown attribute:\n"));
16007 display_raw_attribute (p, end);
16008 p = end;
16009 }
16010 else
16011 attr_len = 0;
16012 }
16013 }
16014 }
16015
16016 free (contents);
16017 }
16018
16019 return res;
16020 }
16021
16022 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
16023 Print the Address, Access and Initial fields of an entry at VMA ADDR
16024 and return the VMA of the next entry, or -1 if there was a problem.
16025 Does not read from DATA_END or beyond. */
16026
16027 static bfd_vma
16028 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
16029 unsigned char * data_end)
16030 {
16031 printf (" ");
16032 print_vma (addr, LONG_HEX);
16033 printf (" ");
16034 if (addr < pltgot + 0xfff0)
16035 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
16036 else
16037 printf ("%10s", "");
16038 printf (" ");
16039 if (data == NULL)
16040 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
16041 else
16042 {
16043 bfd_vma entry;
16044 unsigned char * from = data + addr - pltgot;
16045
16046 if (from + (is_32bit_elf ? 4 : 8) > data_end)
16047 {
16048 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
16049 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
16050 return (bfd_vma) -1;
16051 }
16052 else
16053 {
16054 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
16055 print_vma (entry, LONG_HEX);
16056 }
16057 }
16058 return addr + (is_32bit_elf ? 4 : 8);
16059 }
16060
16061 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
16062 PLTGOT. Print the Address and Initial fields of an entry at VMA
16063 ADDR and return the VMA of the next entry. */
16064
16065 static bfd_vma
16066 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
16067 {
16068 printf (" ");
16069 print_vma (addr, LONG_HEX);
16070 printf (" ");
16071 if (data == NULL)
16072 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
16073 else
16074 {
16075 bfd_vma entry;
16076
16077 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
16078 print_vma (entry, LONG_HEX);
16079 }
16080 return addr + (is_32bit_elf ? 4 : 8);
16081 }
16082
16083 static void
16084 print_mips_ases (unsigned int mask)
16085 {
16086 if (mask & AFL_ASE_DSP)
16087 fputs ("\n\tDSP ASE", stdout);
16088 if (mask & AFL_ASE_DSPR2)
16089 fputs ("\n\tDSP R2 ASE", stdout);
16090 if (mask & AFL_ASE_DSPR3)
16091 fputs ("\n\tDSP R3 ASE", stdout);
16092 if (mask & AFL_ASE_EVA)
16093 fputs ("\n\tEnhanced VA Scheme", stdout);
16094 if (mask & AFL_ASE_MCU)
16095 fputs ("\n\tMCU (MicroController) ASE", stdout);
16096 if (mask & AFL_ASE_MDMX)
16097 fputs ("\n\tMDMX ASE", stdout);
16098 if (mask & AFL_ASE_MIPS3D)
16099 fputs ("\n\tMIPS-3D ASE", stdout);
16100 if (mask & AFL_ASE_MT)
16101 fputs ("\n\tMT ASE", stdout);
16102 if (mask & AFL_ASE_SMARTMIPS)
16103 fputs ("\n\tSmartMIPS ASE", stdout);
16104 if (mask & AFL_ASE_VIRT)
16105 fputs ("\n\tVZ ASE", stdout);
16106 if (mask & AFL_ASE_MSA)
16107 fputs ("\n\tMSA ASE", stdout);
16108 if (mask & AFL_ASE_MIPS16)
16109 fputs ("\n\tMIPS16 ASE", stdout);
16110 if (mask & AFL_ASE_MICROMIPS)
16111 fputs ("\n\tMICROMIPS ASE", stdout);
16112 if (mask & AFL_ASE_XPA)
16113 fputs ("\n\tXPA ASE", stdout);
16114 if (mask & AFL_ASE_MIPS16E2)
16115 fputs ("\n\tMIPS16e2 ASE", stdout);
16116 if (mask & AFL_ASE_CRC)
16117 fputs ("\n\tCRC ASE", stdout);
16118 if (mask & AFL_ASE_GINV)
16119 fputs ("\n\tGINV ASE", stdout);
16120 if (mask & AFL_ASE_LOONGSON_MMI)
16121 fputs ("\n\tLoongson MMI ASE", stdout);
16122 if (mask & AFL_ASE_LOONGSON_CAM)
16123 fputs ("\n\tLoongson CAM ASE", stdout);
16124 if (mask & AFL_ASE_LOONGSON_EXT)
16125 fputs ("\n\tLoongson EXT ASE", stdout);
16126 if (mask & AFL_ASE_LOONGSON_EXT2)
16127 fputs ("\n\tLoongson EXT2 ASE", stdout);
16128 if (mask == 0)
16129 fprintf (stdout, "\n\t%s", _("None"));
16130 else if ((mask & ~AFL_ASE_MASK) != 0)
16131 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
16132 }
16133
16134 static void
16135 print_mips_isa_ext (unsigned int isa_ext)
16136 {
16137 switch (isa_ext)
16138 {
16139 case 0:
16140 fputs (_("None"), stdout);
16141 break;
16142 case AFL_EXT_XLR:
16143 fputs ("RMI XLR", stdout);
16144 break;
16145 case AFL_EXT_OCTEON3:
16146 fputs ("Cavium Networks Octeon3", stdout);
16147 break;
16148 case AFL_EXT_OCTEON2:
16149 fputs ("Cavium Networks Octeon2", stdout);
16150 break;
16151 case AFL_EXT_OCTEONP:
16152 fputs ("Cavium Networks OcteonP", stdout);
16153 break;
16154 case AFL_EXT_OCTEON:
16155 fputs ("Cavium Networks Octeon", stdout);
16156 break;
16157 case AFL_EXT_5900:
16158 fputs ("Toshiba R5900", stdout);
16159 break;
16160 case AFL_EXT_4650:
16161 fputs ("MIPS R4650", stdout);
16162 break;
16163 case AFL_EXT_4010:
16164 fputs ("LSI R4010", stdout);
16165 break;
16166 case AFL_EXT_4100:
16167 fputs ("NEC VR4100", stdout);
16168 break;
16169 case AFL_EXT_3900:
16170 fputs ("Toshiba R3900", stdout);
16171 break;
16172 case AFL_EXT_10000:
16173 fputs ("MIPS R10000", stdout);
16174 break;
16175 case AFL_EXT_SB1:
16176 fputs ("Broadcom SB-1", stdout);
16177 break;
16178 case AFL_EXT_4111:
16179 fputs ("NEC VR4111/VR4181", stdout);
16180 break;
16181 case AFL_EXT_4120:
16182 fputs ("NEC VR4120", stdout);
16183 break;
16184 case AFL_EXT_5400:
16185 fputs ("NEC VR5400", stdout);
16186 break;
16187 case AFL_EXT_5500:
16188 fputs ("NEC VR5500", stdout);
16189 break;
16190 case AFL_EXT_LOONGSON_2E:
16191 fputs ("ST Microelectronics Loongson 2E", stdout);
16192 break;
16193 case AFL_EXT_LOONGSON_2F:
16194 fputs ("ST Microelectronics Loongson 2F", stdout);
16195 break;
16196 case AFL_EXT_INTERAPTIV_MR2:
16197 fputs ("Imagination interAptiv MR2", stdout);
16198 break;
16199 default:
16200 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
16201 }
16202 }
16203
16204 static signed int
16205 get_mips_reg_size (int reg_size)
16206 {
16207 return (reg_size == AFL_REG_NONE) ? 0
16208 : (reg_size == AFL_REG_32) ? 32
16209 : (reg_size == AFL_REG_64) ? 64
16210 : (reg_size == AFL_REG_128) ? 128
16211 : -1;
16212 }
16213
16214 static bfd_boolean
16215 process_mips_specific (Filedata * filedata)
16216 {
16217 Elf_Internal_Dyn * entry;
16218 Elf_Internal_Shdr *sect = NULL;
16219 size_t liblist_offset = 0;
16220 size_t liblistno = 0;
16221 size_t conflictsno = 0;
16222 size_t options_offset = 0;
16223 size_t conflicts_offset = 0;
16224 size_t pltrelsz = 0;
16225 size_t pltrel = 0;
16226 bfd_vma pltgot = 0;
16227 bfd_vma mips_pltgot = 0;
16228 bfd_vma jmprel = 0;
16229 bfd_vma local_gotno = 0;
16230 bfd_vma gotsym = 0;
16231 bfd_vma symtabno = 0;
16232 bfd_boolean res = TRUE;
16233
16234 if (! process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
16235 display_mips_gnu_attribute))
16236 res = FALSE;
16237
16238 sect = find_section (filedata, ".MIPS.abiflags");
16239
16240 if (sect != NULL)
16241 {
16242 Elf_External_ABIFlags_v0 *abiflags_ext;
16243 Elf_Internal_ABIFlags_v0 abiflags_in;
16244
16245 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
16246 {
16247 error (_("Corrupt MIPS ABI Flags section.\n"));
16248 res = FALSE;
16249 }
16250 else
16251 {
16252 abiflags_ext = get_data (NULL, filedata, sect->sh_offset, 1,
16253 sect->sh_size, _("MIPS ABI Flags section"));
16254 if (abiflags_ext)
16255 {
16256 abiflags_in.version = BYTE_GET (abiflags_ext->version);
16257 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
16258 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
16259 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
16260 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
16261 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
16262 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
16263 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
16264 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
16265 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
16266 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
16267
16268 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
16269 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
16270 if (abiflags_in.isa_rev > 1)
16271 printf ("r%d", abiflags_in.isa_rev);
16272 printf ("\nGPR size: %d",
16273 get_mips_reg_size (abiflags_in.gpr_size));
16274 printf ("\nCPR1 size: %d",
16275 get_mips_reg_size (abiflags_in.cpr1_size));
16276 printf ("\nCPR2 size: %d",
16277 get_mips_reg_size (abiflags_in.cpr2_size));
16278 fputs ("\nFP ABI: ", stdout);
16279 print_mips_fp_abi_value (abiflags_in.fp_abi);
16280 fputs ("ISA Extension: ", stdout);
16281 print_mips_isa_ext (abiflags_in.isa_ext);
16282 fputs ("\nASEs:", stdout);
16283 print_mips_ases (abiflags_in.ases);
16284 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
16285 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
16286 fputc ('\n', stdout);
16287 free (abiflags_ext);
16288 }
16289 }
16290 }
16291
16292 /* We have a lot of special sections. Thanks SGI! */
16293 if (dynamic_section == NULL)
16294 {
16295 /* No dynamic information available. See if there is static GOT. */
16296 sect = find_section (filedata, ".got");
16297 if (sect != NULL)
16298 {
16299 unsigned char *data_end;
16300 unsigned char *data;
16301 bfd_vma ent, end;
16302 int addr_size;
16303
16304 pltgot = sect->sh_addr;
16305
16306 ent = pltgot;
16307 addr_size = (is_32bit_elf ? 4 : 8);
16308 end = pltgot + sect->sh_size;
16309
16310 data = (unsigned char *) get_data (NULL, filedata, sect->sh_offset,
16311 end - pltgot, 1,
16312 _("Global Offset Table data"));
16313 /* PR 12855: Null data is handled gracefully throughout. */
16314 data_end = data + (end - pltgot);
16315
16316 printf (_("\nStatic GOT:\n"));
16317 printf (_(" Canonical gp value: "));
16318 print_vma (ent + 0x7ff0, LONG_HEX);
16319 printf ("\n\n");
16320
16321 /* In a dynamic binary GOT[0] is reserved for the dynamic
16322 loader to store the lazy resolver pointer, however in
16323 a static binary it may well have been omitted and GOT
16324 reduced to a table of addresses.
16325 PR 21344: Check for the entry being fully available
16326 before fetching it. */
16327 if (data
16328 && data + ent - pltgot + addr_size <= data_end
16329 && byte_get (data + ent - pltgot, addr_size) == 0)
16330 {
16331 printf (_(" Reserved entries:\n"));
16332 printf (_(" %*s %10s %*s\n"),
16333 addr_size * 2, _("Address"), _("Access"),
16334 addr_size * 2, _("Value"));
16335 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16336 printf ("\n");
16337 if (ent == (bfd_vma) -1)
16338 goto sgot_print_fail;
16339
16340 /* Check for the MSB of GOT[1] being set, identifying a
16341 GNU object. This entry will be used by some runtime
16342 loaders, to store the module pointer. Otherwise this
16343 is an ordinary local entry.
16344 PR 21344: Check for the entry being fully available
16345 before fetching it. */
16346 if (data
16347 && data + ent - pltgot + addr_size <= data_end
16348 && (byte_get (data + ent - pltgot, addr_size)
16349 >> (addr_size * 8 - 1)) != 0)
16350 {
16351 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16352 printf ("\n");
16353 if (ent == (bfd_vma) -1)
16354 goto sgot_print_fail;
16355 }
16356 printf ("\n");
16357 }
16358
16359 if (data != NULL && ent < end)
16360 {
16361 printf (_(" Local entries:\n"));
16362 printf (" %*s %10s %*s\n",
16363 addr_size * 2, _("Address"), _("Access"),
16364 addr_size * 2, _("Value"));
16365 while (ent < end)
16366 {
16367 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16368 printf ("\n");
16369 if (ent == (bfd_vma) -1)
16370 goto sgot_print_fail;
16371 }
16372 printf ("\n");
16373 }
16374
16375 sgot_print_fail:
16376 if (data)
16377 free (data);
16378 }
16379 return res;
16380 }
16381
16382 for (entry = dynamic_section;
16383 /* PR 17531 file: 012-50589-0.004. */
16384 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
16385 ++entry)
16386 switch (entry->d_tag)
16387 {
16388 case DT_MIPS_LIBLIST:
16389 liblist_offset
16390 = offset_from_vma (filedata, entry->d_un.d_val,
16391 liblistno * sizeof (Elf32_External_Lib));
16392 break;
16393 case DT_MIPS_LIBLISTNO:
16394 liblistno = entry->d_un.d_val;
16395 break;
16396 case DT_MIPS_OPTIONS:
16397 options_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
16398 break;
16399 case DT_MIPS_CONFLICT:
16400 conflicts_offset
16401 = offset_from_vma (filedata, entry->d_un.d_val,
16402 conflictsno * sizeof (Elf32_External_Conflict));
16403 break;
16404 case DT_MIPS_CONFLICTNO:
16405 conflictsno = entry->d_un.d_val;
16406 break;
16407 case DT_PLTGOT:
16408 pltgot = entry->d_un.d_ptr;
16409 break;
16410 case DT_MIPS_LOCAL_GOTNO:
16411 local_gotno = entry->d_un.d_val;
16412 break;
16413 case DT_MIPS_GOTSYM:
16414 gotsym = entry->d_un.d_val;
16415 break;
16416 case DT_MIPS_SYMTABNO:
16417 symtabno = entry->d_un.d_val;
16418 break;
16419 case DT_MIPS_PLTGOT:
16420 mips_pltgot = entry->d_un.d_ptr;
16421 break;
16422 case DT_PLTREL:
16423 pltrel = entry->d_un.d_val;
16424 break;
16425 case DT_PLTRELSZ:
16426 pltrelsz = entry->d_un.d_val;
16427 break;
16428 case DT_JMPREL:
16429 jmprel = entry->d_un.d_ptr;
16430 break;
16431 default:
16432 break;
16433 }
16434
16435 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
16436 {
16437 Elf32_External_Lib * elib;
16438 size_t cnt;
16439
16440 elib = (Elf32_External_Lib *) get_data (NULL, filedata, liblist_offset,
16441 liblistno,
16442 sizeof (Elf32_External_Lib),
16443 _("liblist section data"));
16444 if (elib)
16445 {
16446 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16447 "\nSection '.liblist' contains %lu entries:\n",
16448 (unsigned long) liblistno),
16449 (unsigned long) liblistno);
16450 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
16451 stdout);
16452
16453 for (cnt = 0; cnt < liblistno; ++cnt)
16454 {
16455 Elf32_Lib liblist;
16456 time_t atime;
16457 char timebuf[128];
16458 struct tm * tmp;
16459
16460 liblist.l_name = BYTE_GET (elib[cnt].l_name);
16461 atime = BYTE_GET (elib[cnt].l_time_stamp);
16462 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16463 liblist.l_version = BYTE_GET (elib[cnt].l_version);
16464 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16465
16466 tmp = gmtime (&atime);
16467 snprintf (timebuf, sizeof (timebuf),
16468 "%04u-%02u-%02uT%02u:%02u:%02u",
16469 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16470 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16471
16472 printf ("%3lu: ", (unsigned long) cnt);
16473 if (VALID_DYNAMIC_NAME (liblist.l_name))
16474 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
16475 else
16476 printf (_("<corrupt: %9ld>"), liblist.l_name);
16477 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
16478 liblist.l_version);
16479
16480 if (liblist.l_flags == 0)
16481 puts (_(" NONE"));
16482 else
16483 {
16484 static const struct
16485 {
16486 const char * name;
16487 int bit;
16488 }
16489 l_flags_vals[] =
16490 {
16491 { " EXACT_MATCH", LL_EXACT_MATCH },
16492 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
16493 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
16494 { " EXPORTS", LL_EXPORTS },
16495 { " DELAY_LOAD", LL_DELAY_LOAD },
16496 { " DELTA", LL_DELTA }
16497 };
16498 int flags = liblist.l_flags;
16499 size_t fcnt;
16500
16501 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
16502 if ((flags & l_flags_vals[fcnt].bit) != 0)
16503 {
16504 fputs (l_flags_vals[fcnt].name, stdout);
16505 flags ^= l_flags_vals[fcnt].bit;
16506 }
16507 if (flags != 0)
16508 printf (" %#x", (unsigned int) flags);
16509
16510 puts ("");
16511 }
16512 }
16513
16514 free (elib);
16515 }
16516 else
16517 res = FALSE;
16518 }
16519
16520 if (options_offset != 0)
16521 {
16522 Elf_External_Options * eopt;
16523 size_t offset;
16524 int cnt;
16525 sect = filedata->section_headers;
16526
16527 /* Find the section header so that we get the size. */
16528 sect = find_section_by_type (filedata, SHT_MIPS_OPTIONS);
16529 /* PR 17533 file: 012-277276-0.004. */
16530 if (sect == NULL)
16531 {
16532 error (_("No MIPS_OPTIONS header found\n"));
16533 return FALSE;
16534 }
16535 /* PR 24243 */
16536 if (sect->sh_size < sizeof (* eopt))
16537 {
16538 error (_("The MIPS options section is too small.\n"));
16539 return FALSE;
16540 }
16541
16542 eopt = (Elf_External_Options *) get_data (NULL, filedata, options_offset, 1,
16543 sect->sh_size, _("options"));
16544 if (eopt)
16545 {
16546 Elf_Internal_Options * iopt;
16547 Elf_Internal_Options * option;
16548 Elf_Internal_Options * iopt_end;
16549
16550 iopt = (Elf_Internal_Options *)
16551 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
16552 if (iopt == NULL)
16553 {
16554 error (_("Out of memory allocating space for MIPS options\n"));
16555 return FALSE;
16556 }
16557
16558 offset = cnt = 0;
16559 option = iopt;
16560 iopt_end = iopt + (sect->sh_size / sizeof (eopt));
16561
16562 while (offset <= sect->sh_size - sizeof (* eopt))
16563 {
16564 Elf_External_Options * eoption;
16565
16566 eoption = (Elf_External_Options *) ((char *) eopt + offset);
16567
16568 option->kind = BYTE_GET (eoption->kind);
16569 option->size = BYTE_GET (eoption->size);
16570 option->section = BYTE_GET (eoption->section);
16571 option->info = BYTE_GET (eoption->info);
16572
16573 /* PR 17531: file: ffa0fa3b. */
16574 if (option->size < sizeof (* eopt)
16575 || offset + option->size > sect->sh_size)
16576 {
16577 error (_("Invalid size (%u) for MIPS option\n"), option->size);
16578 return FALSE;
16579 }
16580 offset += option->size;
16581
16582 ++option;
16583 ++cnt;
16584 }
16585
16586 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16587 "\nSection '%s' contains %d entries:\n",
16588 cnt),
16589 printable_section_name (filedata, sect), cnt);
16590
16591 option = iopt;
16592 offset = 0;
16593
16594 while (cnt-- > 0)
16595 {
16596 size_t len;
16597
16598 switch (option->kind)
16599 {
16600 case ODK_NULL:
16601 /* This shouldn't happen. */
16602 printf (" NULL %d %lx", option->section, option->info);
16603 break;
16604
16605 case ODK_REGINFO:
16606 printf (" REGINFO ");
16607 if (filedata->file_header.e_machine == EM_MIPS)
16608 {
16609 Elf32_External_RegInfo * ereg;
16610 Elf32_RegInfo reginfo;
16611
16612 /* 32bit form. */
16613 if (option + 2 > iopt_end)
16614 {
16615 printf (_("<corrupt>\n"));
16616 error (_("Truncated MIPS REGINFO option\n"));
16617 cnt = 0;
16618 break;
16619 }
16620
16621 ereg = (Elf32_External_RegInfo *) (option + 1);
16622
16623 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
16624 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16625 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16626 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16627 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16628 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
16629
16630 printf ("GPR %08lx GP 0x%lx\n",
16631 reginfo.ri_gprmask,
16632 (unsigned long) reginfo.ri_gp_value);
16633 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16634 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16635 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16636 }
16637 else
16638 {
16639 /* 64 bit form. */
16640 Elf64_External_RegInfo * ereg;
16641 Elf64_Internal_RegInfo reginfo;
16642
16643 if (option + 2 > iopt_end)
16644 {
16645 printf (_("<corrupt>\n"));
16646 error (_("Truncated MIPS REGINFO option\n"));
16647 cnt = 0;
16648 break;
16649 }
16650
16651 ereg = (Elf64_External_RegInfo *) (option + 1);
16652 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
16653 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16654 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16655 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16656 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16657 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
16658
16659 printf ("GPR %08lx GP 0x",
16660 reginfo.ri_gprmask);
16661 printf_vma (reginfo.ri_gp_value);
16662 printf ("\n");
16663
16664 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16665 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16666 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16667 }
16668 ++option;
16669 continue;
16670
16671 case ODK_EXCEPTIONS:
16672 fputs (" EXCEPTIONS fpe_min(", stdout);
16673 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
16674 fputs (") fpe_max(", stdout);
16675 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
16676 fputs (")", stdout);
16677
16678 if (option->info & OEX_PAGE0)
16679 fputs (" PAGE0", stdout);
16680 if (option->info & OEX_SMM)
16681 fputs (" SMM", stdout);
16682 if (option->info & OEX_FPDBUG)
16683 fputs (" FPDBUG", stdout);
16684 if (option->info & OEX_DISMISS)
16685 fputs (" DISMISS", stdout);
16686 break;
16687
16688 case ODK_PAD:
16689 fputs (" PAD ", stdout);
16690 if (option->info & OPAD_PREFIX)
16691 fputs (" PREFIX", stdout);
16692 if (option->info & OPAD_POSTFIX)
16693 fputs (" POSTFIX", stdout);
16694 if (option->info & OPAD_SYMBOL)
16695 fputs (" SYMBOL", stdout);
16696 break;
16697
16698 case ODK_HWPATCH:
16699 fputs (" HWPATCH ", stdout);
16700 if (option->info & OHW_R4KEOP)
16701 fputs (" R4KEOP", stdout);
16702 if (option->info & OHW_R8KPFETCH)
16703 fputs (" R8KPFETCH", stdout);
16704 if (option->info & OHW_R5KEOP)
16705 fputs (" R5KEOP", stdout);
16706 if (option->info & OHW_R5KCVTL)
16707 fputs (" R5KCVTL", stdout);
16708 break;
16709
16710 case ODK_FILL:
16711 fputs (" FILL ", stdout);
16712 /* XXX Print content of info word? */
16713 break;
16714
16715 case ODK_TAGS:
16716 fputs (" TAGS ", stdout);
16717 /* XXX Print content of info word? */
16718 break;
16719
16720 case ODK_HWAND:
16721 fputs (" HWAND ", stdout);
16722 if (option->info & OHWA0_R4KEOP_CHECKED)
16723 fputs (" R4KEOP_CHECKED", stdout);
16724 if (option->info & OHWA0_R4KEOP_CLEAN)
16725 fputs (" R4KEOP_CLEAN", stdout);
16726 break;
16727
16728 case ODK_HWOR:
16729 fputs (" HWOR ", stdout);
16730 if (option->info & OHWA0_R4KEOP_CHECKED)
16731 fputs (" R4KEOP_CHECKED", stdout);
16732 if (option->info & OHWA0_R4KEOP_CLEAN)
16733 fputs (" R4KEOP_CLEAN", stdout);
16734 break;
16735
16736 case ODK_GP_GROUP:
16737 printf (" GP_GROUP %#06lx self-contained %#06lx",
16738 option->info & OGP_GROUP,
16739 (option->info & OGP_SELF) >> 16);
16740 break;
16741
16742 case ODK_IDENT:
16743 printf (" IDENT %#06lx self-contained %#06lx",
16744 option->info & OGP_GROUP,
16745 (option->info & OGP_SELF) >> 16);
16746 break;
16747
16748 default:
16749 /* This shouldn't happen. */
16750 printf (" %3d ??? %d %lx",
16751 option->kind, option->section, option->info);
16752 break;
16753 }
16754
16755 len = sizeof (* eopt);
16756 while (len < option->size)
16757 {
16758 unsigned char datum = * ((unsigned char *) eopt + offset + len);
16759
16760 if (ISPRINT (datum))
16761 printf ("%c", datum);
16762 else
16763 printf ("\\%03o", datum);
16764 len ++;
16765 }
16766 fputs ("\n", stdout);
16767
16768 offset += option->size;
16769 ++option;
16770 }
16771
16772 free (eopt);
16773 }
16774 else
16775 res = FALSE;
16776 }
16777
16778 if (conflicts_offset != 0 && conflictsno != 0)
16779 {
16780 Elf32_Conflict * iconf;
16781 size_t cnt;
16782
16783 if (dynamic_symbols == NULL)
16784 {
16785 error (_("conflict list found without a dynamic symbol table\n"));
16786 return FALSE;
16787 }
16788
16789 /* PR 21345 - print a slightly more helpful error message
16790 if we are sure that the cmalloc will fail. */
16791 if (conflictsno * sizeof (* iconf) > filedata->file_size)
16792 {
16793 error (_("Overlarge number of conflicts detected: %lx\n"),
16794 (long) conflictsno);
16795 return FALSE;
16796 }
16797
16798 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
16799 if (iconf == NULL)
16800 {
16801 error (_("Out of memory allocating space for dynamic conflicts\n"));
16802 return FALSE;
16803 }
16804
16805 if (is_32bit_elf)
16806 {
16807 Elf32_External_Conflict * econf32;
16808
16809 econf32 = (Elf32_External_Conflict *)
16810 get_data (NULL, filedata, conflicts_offset, conflictsno,
16811 sizeof (* econf32), _("conflict"));
16812 if (!econf32)
16813 return FALSE;
16814
16815 for (cnt = 0; cnt < conflictsno; ++cnt)
16816 iconf[cnt] = BYTE_GET (econf32[cnt]);
16817
16818 free (econf32);
16819 }
16820 else
16821 {
16822 Elf64_External_Conflict * econf64;
16823
16824 econf64 = (Elf64_External_Conflict *)
16825 get_data (NULL, filedata, conflicts_offset, conflictsno,
16826 sizeof (* econf64), _("conflict"));
16827 if (!econf64)
16828 return FALSE;
16829
16830 for (cnt = 0; cnt < conflictsno; ++cnt)
16831 iconf[cnt] = BYTE_GET (econf64[cnt]);
16832
16833 free (econf64);
16834 }
16835
16836 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16837 "\nSection '.conflict' contains %lu entries:\n",
16838 (unsigned long) conflictsno),
16839 (unsigned long) conflictsno);
16840 puts (_(" Num: Index Value Name"));
16841
16842 for (cnt = 0; cnt < conflictsno; ++cnt)
16843 {
16844 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
16845
16846 if (iconf[cnt] >= num_dynamic_syms)
16847 printf (_("<corrupt symbol index>"));
16848 else
16849 {
16850 Elf_Internal_Sym * psym;
16851
16852 psym = & dynamic_symbols[iconf[cnt]];
16853 print_vma (psym->st_value, FULL_HEX);
16854 putchar (' ');
16855 if (VALID_DYNAMIC_NAME (psym->st_name))
16856 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
16857 else
16858 printf (_("<corrupt: %14ld>"), psym->st_name);
16859 }
16860 putchar ('\n');
16861 }
16862
16863 free (iconf);
16864 }
16865
16866 if (pltgot != 0 && local_gotno != 0)
16867 {
16868 bfd_vma ent, local_end, global_end;
16869 size_t i, offset;
16870 unsigned char * data;
16871 unsigned char * data_end;
16872 int addr_size;
16873
16874 ent = pltgot;
16875 addr_size = (is_32bit_elf ? 4 : 8);
16876 local_end = pltgot + local_gotno * addr_size;
16877
16878 /* PR binutils/17533 file: 012-111227-0.004 */
16879 if (symtabno < gotsym)
16880 {
16881 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16882 (unsigned long) gotsym, (unsigned long) symtabno);
16883 return FALSE;
16884 }
16885
16886 global_end = local_end + (symtabno - gotsym) * addr_size;
16887 /* PR 17531: file: 54c91a34. */
16888 if (global_end < local_end)
16889 {
16890 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
16891 return FALSE;
16892 }
16893
16894 offset = offset_from_vma (filedata, pltgot, global_end - pltgot);
16895 data = (unsigned char *) get_data (NULL, filedata, offset,
16896 global_end - pltgot, 1,
16897 _("Global Offset Table data"));
16898 /* PR 12855: Null data is handled gracefully throughout. */
16899 data_end = data + (global_end - pltgot);
16900
16901 printf (_("\nPrimary GOT:\n"));
16902 printf (_(" Canonical gp value: "));
16903 print_vma (pltgot + 0x7ff0, LONG_HEX);
16904 printf ("\n\n");
16905
16906 printf (_(" Reserved entries:\n"));
16907 printf (_(" %*s %10s %*s Purpose\n"),
16908 addr_size * 2, _("Address"), _("Access"),
16909 addr_size * 2, _("Initial"));
16910 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16911 printf (_(" Lazy resolver\n"));
16912 if (ent == (bfd_vma) -1)
16913 goto got_print_fail;
16914
16915 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16916 This entry will be used by some runtime loaders, to store the
16917 module pointer. Otherwise this is an ordinary local entry.
16918 PR 21344: Check for the entry being fully available before
16919 fetching it. */
16920 if (data
16921 && data + ent - pltgot + addr_size <= data_end
16922 && (byte_get (data + ent - pltgot, addr_size)
16923 >> (addr_size * 8 - 1)) != 0)
16924 {
16925 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16926 printf (_(" Module pointer (GNU extension)\n"));
16927 if (ent == (bfd_vma) -1)
16928 goto got_print_fail;
16929 }
16930 printf ("\n");
16931
16932 if (data != NULL && ent < local_end)
16933 {
16934 printf (_(" Local entries:\n"));
16935 printf (" %*s %10s %*s\n",
16936 addr_size * 2, _("Address"), _("Access"),
16937 addr_size * 2, _("Initial"));
16938 while (ent < local_end)
16939 {
16940 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16941 printf ("\n");
16942 if (ent == (bfd_vma) -1)
16943 goto got_print_fail;
16944 }
16945 printf ("\n");
16946 }
16947
16948 if (data != NULL && gotsym < symtabno)
16949 {
16950 int sym_width;
16951
16952 printf (_(" Global entries:\n"));
16953 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
16954 addr_size * 2, _("Address"),
16955 _("Access"),
16956 addr_size * 2, _("Initial"),
16957 addr_size * 2, _("Sym.Val."),
16958 _("Type"),
16959 /* Note for translators: "Ndx" = abbreviated form of "Index". */
16960 _("Ndx"), _("Name"));
16961
16962 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
16963
16964 for (i = gotsym; i < symtabno; i++)
16965 {
16966 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16967 printf (" ");
16968
16969 if (dynamic_symbols == NULL)
16970 printf (_("<no dynamic symbols>"));
16971 else if (i < num_dynamic_syms)
16972 {
16973 Elf_Internal_Sym * psym = dynamic_symbols + i;
16974
16975 print_vma (psym->st_value, LONG_HEX);
16976 printf (" %-7s %3s ",
16977 get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16978 get_symbol_index_type (filedata, psym->st_shndx));
16979
16980 if (VALID_DYNAMIC_NAME (psym->st_name))
16981 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16982 else
16983 printf (_("<corrupt: %14ld>"), psym->st_name);
16984 }
16985 else
16986 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16987 (unsigned long) i);
16988
16989 printf ("\n");
16990 if (ent == (bfd_vma) -1)
16991 break;
16992 }
16993 printf ("\n");
16994 }
16995
16996 got_print_fail:
16997 if (data)
16998 free (data);
16999 }
17000
17001 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
17002 {
17003 bfd_vma ent, end;
17004 size_t offset, rel_offset;
17005 unsigned long count, i;
17006 unsigned char * data;
17007 int addr_size, sym_width;
17008 Elf_Internal_Rela * rels;
17009
17010 rel_offset = offset_from_vma (filedata, jmprel, pltrelsz);
17011 if (pltrel == DT_RELA)
17012 {
17013 if (!slurp_rela_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
17014 return FALSE;
17015 }
17016 else
17017 {
17018 if (!slurp_rel_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
17019 return FALSE;
17020 }
17021
17022 ent = mips_pltgot;
17023 addr_size = (is_32bit_elf ? 4 : 8);
17024 end = mips_pltgot + (2 + count) * addr_size;
17025
17026 offset = offset_from_vma (filedata, mips_pltgot, end - mips_pltgot);
17027 data = (unsigned char *) get_data (NULL, filedata, offset, end - mips_pltgot,
17028 1, _("Procedure Linkage Table data"));
17029 if (data == NULL)
17030 return FALSE;
17031
17032 printf ("\nPLT GOT:\n\n");
17033 printf (_(" Reserved entries:\n"));
17034 printf (_(" %*s %*s Purpose\n"),
17035 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
17036 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
17037 printf (_(" PLT lazy resolver\n"));
17038 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
17039 printf (_(" Module pointer\n"));
17040 printf ("\n");
17041
17042 printf (_(" Entries:\n"));
17043 printf (" %*s %*s %*s %-7s %3s %s\n",
17044 addr_size * 2, _("Address"),
17045 addr_size * 2, _("Initial"),
17046 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
17047 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
17048 for (i = 0; i < count; i++)
17049 {
17050 unsigned long idx = get_reloc_symindex (rels[i].r_info);
17051
17052 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
17053 printf (" ");
17054
17055 if (idx >= num_dynamic_syms)
17056 printf (_("<corrupt symbol index: %lu>"), idx);
17057 else
17058 {
17059 Elf_Internal_Sym * psym = dynamic_symbols + idx;
17060
17061 print_vma (psym->st_value, LONG_HEX);
17062 printf (" %-7s %3s ",
17063 get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
17064 get_symbol_index_type (filedata, psym->st_shndx));
17065 if (VALID_DYNAMIC_NAME (psym->st_name))
17066 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
17067 else
17068 printf (_("<corrupt: %14ld>"), psym->st_name);
17069 }
17070 printf ("\n");
17071 }
17072 printf ("\n");
17073
17074 if (data)
17075 free (data);
17076 free (rels);
17077 }
17078
17079 return res;
17080 }
17081
17082 static bfd_boolean
17083 process_nds32_specific (Filedata * filedata)
17084 {
17085 Elf_Internal_Shdr *sect = NULL;
17086
17087 sect = find_section (filedata, ".nds32_e_flags");
17088 if (sect != NULL)
17089 {
17090 unsigned int *flag;
17091
17092 printf ("\nNDS32 elf flags section:\n");
17093 flag = get_data (NULL, filedata, sect->sh_offset, 1,
17094 sect->sh_size, _("NDS32 elf flags section"));
17095
17096 if (! flag)
17097 return FALSE;
17098
17099 switch ((*flag) & 0x3)
17100 {
17101 case 0:
17102 printf ("(VEC_SIZE):\tNo entry.\n");
17103 break;
17104 case 1:
17105 printf ("(VEC_SIZE):\t4 bytes\n");
17106 break;
17107 case 2:
17108 printf ("(VEC_SIZE):\t16 bytes\n");
17109 break;
17110 case 3:
17111 printf ("(VEC_SIZE):\treserved\n");
17112 break;
17113 }
17114 }
17115
17116 return TRUE;
17117 }
17118
17119 static bfd_boolean
17120 process_gnu_liblist (Filedata * filedata)
17121 {
17122 Elf_Internal_Shdr * section;
17123 Elf_Internal_Shdr * string_sec;
17124 Elf32_External_Lib * elib;
17125 char * strtab;
17126 size_t strtab_size;
17127 size_t cnt;
17128 unsigned long num_liblist;
17129 unsigned i;
17130 bfd_boolean res = TRUE;
17131
17132 if (! do_arch)
17133 return TRUE;
17134
17135 for (i = 0, section = filedata->section_headers;
17136 i < filedata->file_header.e_shnum;
17137 i++, section++)
17138 {
17139 switch (section->sh_type)
17140 {
17141 case SHT_GNU_LIBLIST:
17142 if (section->sh_link >= filedata->file_header.e_shnum)
17143 break;
17144
17145 elib = (Elf32_External_Lib *)
17146 get_data (NULL, filedata, section->sh_offset, 1, section->sh_size,
17147 _("liblist section data"));
17148
17149 if (elib == NULL)
17150 {
17151 res = FALSE;
17152 break;
17153 }
17154
17155 string_sec = filedata->section_headers + section->sh_link;
17156 strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
17157 string_sec->sh_size,
17158 _("liblist string table"));
17159 if (strtab == NULL
17160 || section->sh_entsize != sizeof (Elf32_External_Lib))
17161 {
17162 free (elib);
17163 free (strtab);
17164 res = FALSE;
17165 break;
17166 }
17167 strtab_size = string_sec->sh_size;
17168
17169 num_liblist = section->sh_size / sizeof (Elf32_External_Lib);
17170 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17171 "\nLibrary list section '%s' contains %lu entries:\n",
17172 num_liblist),
17173 printable_section_name (filedata, section),
17174 num_liblist);
17175
17176 puts (_(" Library Time Stamp Checksum Version Flags"));
17177
17178 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
17179 ++cnt)
17180 {
17181 Elf32_Lib liblist;
17182 time_t atime;
17183 char timebuf[128];
17184 struct tm * tmp;
17185
17186 liblist.l_name = BYTE_GET (elib[cnt].l_name);
17187 atime = BYTE_GET (elib[cnt].l_time_stamp);
17188 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
17189 liblist.l_version = BYTE_GET (elib[cnt].l_version);
17190 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
17191
17192 tmp = gmtime (&atime);
17193 snprintf (timebuf, sizeof (timebuf),
17194 "%04u-%02u-%02uT%02u:%02u:%02u",
17195 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
17196 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
17197
17198 printf ("%3lu: ", (unsigned long) cnt);
17199 if (do_wide)
17200 printf ("%-20s", liblist.l_name < strtab_size
17201 ? strtab + liblist.l_name : _("<corrupt>"));
17202 else
17203 printf ("%-20.20s", liblist.l_name < strtab_size
17204 ? strtab + liblist.l_name : _("<corrupt>"));
17205 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
17206 liblist.l_version, liblist.l_flags);
17207 }
17208
17209 free (elib);
17210 free (strtab);
17211 }
17212 }
17213
17214 return res;
17215 }
17216
17217 static const char *
17218 get_note_type (Filedata * filedata, unsigned e_type)
17219 {
17220 static char buff[64];
17221
17222 if (filedata->file_header.e_type == ET_CORE)
17223 switch (e_type)
17224 {
17225 case NT_AUXV:
17226 return _("NT_AUXV (auxiliary vector)");
17227 case NT_PRSTATUS:
17228 return _("NT_PRSTATUS (prstatus structure)");
17229 case NT_FPREGSET:
17230 return _("NT_FPREGSET (floating point registers)");
17231 case NT_PRPSINFO:
17232 return _("NT_PRPSINFO (prpsinfo structure)");
17233 case NT_TASKSTRUCT:
17234 return _("NT_TASKSTRUCT (task structure)");
17235 case NT_PRXFPREG:
17236 return _("NT_PRXFPREG (user_xfpregs structure)");
17237 case NT_PPC_VMX:
17238 return _("NT_PPC_VMX (ppc Altivec registers)");
17239 case NT_PPC_VSX:
17240 return _("NT_PPC_VSX (ppc VSX registers)");
17241 case NT_PPC_TAR:
17242 return _("NT_PPC_TAR (ppc TAR register)");
17243 case NT_PPC_PPR:
17244 return _("NT_PPC_PPR (ppc PPR register)");
17245 case NT_PPC_DSCR:
17246 return _("NT_PPC_DSCR (ppc DSCR register)");
17247 case NT_PPC_EBB:
17248 return _("NT_PPC_EBB (ppc EBB registers)");
17249 case NT_PPC_PMU:
17250 return _("NT_PPC_PMU (ppc PMU registers)");
17251 case NT_PPC_TM_CGPR:
17252 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17253 case NT_PPC_TM_CFPR:
17254 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17255 case NT_PPC_TM_CVMX:
17256 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17257 case NT_PPC_TM_CVSX:
17258 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17259 case NT_PPC_TM_SPR:
17260 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17261 case NT_PPC_TM_CTAR:
17262 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17263 case NT_PPC_TM_CPPR:
17264 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17265 case NT_PPC_TM_CDSCR:
17266 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17267 case NT_386_TLS:
17268 return _("NT_386_TLS (x86 TLS information)");
17269 case NT_386_IOPERM:
17270 return _("NT_386_IOPERM (x86 I/O permissions)");
17271 case NT_X86_XSTATE:
17272 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17273 case NT_S390_HIGH_GPRS:
17274 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17275 case NT_S390_TIMER:
17276 return _("NT_S390_TIMER (s390 timer register)");
17277 case NT_S390_TODCMP:
17278 return _("NT_S390_TODCMP (s390 TOD comparator register)");
17279 case NT_S390_TODPREG:
17280 return _("NT_S390_TODPREG (s390 TOD programmable register)");
17281 case NT_S390_CTRS:
17282 return _("NT_S390_CTRS (s390 control registers)");
17283 case NT_S390_PREFIX:
17284 return _("NT_S390_PREFIX (s390 prefix register)");
17285 case NT_S390_LAST_BREAK:
17286 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17287 case NT_S390_SYSTEM_CALL:
17288 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17289 case NT_S390_TDB:
17290 return _("NT_S390_TDB (s390 transaction diagnostic block)");
17291 case NT_S390_VXRS_LOW:
17292 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17293 case NT_S390_VXRS_HIGH:
17294 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17295 case NT_S390_GS_CB:
17296 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17297 case NT_S390_GS_BC:
17298 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17299 case NT_ARM_VFP:
17300 return _("NT_ARM_VFP (arm VFP registers)");
17301 case NT_ARM_TLS:
17302 return _("NT_ARM_TLS (AArch TLS registers)");
17303 case NT_ARM_HW_BREAK:
17304 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17305 case NT_ARM_HW_WATCH:
17306 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17307 case NT_PSTATUS:
17308 return _("NT_PSTATUS (pstatus structure)");
17309 case NT_FPREGS:
17310 return _("NT_FPREGS (floating point registers)");
17311 case NT_PSINFO:
17312 return _("NT_PSINFO (psinfo structure)");
17313 case NT_LWPSTATUS:
17314 return _("NT_LWPSTATUS (lwpstatus_t structure)");
17315 case NT_LWPSINFO:
17316 return _("NT_LWPSINFO (lwpsinfo_t structure)");
17317 case NT_WIN32PSTATUS:
17318 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
17319 case NT_SIGINFO:
17320 return _("NT_SIGINFO (siginfo_t data)");
17321 case NT_FILE:
17322 return _("NT_FILE (mapped files)");
17323 default:
17324 break;
17325 }
17326 else
17327 switch (e_type)
17328 {
17329 case NT_VERSION:
17330 return _("NT_VERSION (version)");
17331 case NT_ARCH:
17332 return _("NT_ARCH (architecture)");
17333 case NT_GNU_BUILD_ATTRIBUTE_OPEN:
17334 return _("OPEN");
17335 case NT_GNU_BUILD_ATTRIBUTE_FUNC:
17336 return _("func");
17337 default:
17338 break;
17339 }
17340
17341 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17342 return buff;
17343 }
17344
17345 static bfd_boolean
17346 print_core_note (Elf_Internal_Note *pnote)
17347 {
17348 unsigned int addr_size = is_32bit_elf ? 4 : 8;
17349 bfd_vma count, page_size;
17350 unsigned char *descdata, *filenames, *descend;
17351
17352 if (pnote->type != NT_FILE)
17353 {
17354 if (do_wide)
17355 printf ("\n");
17356 return TRUE;
17357 }
17358
17359 #ifndef BFD64
17360 if (!is_32bit_elf)
17361 {
17362 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
17363 /* Still "successful". */
17364 return TRUE;
17365 }
17366 #endif
17367
17368 if (pnote->descsz < 2 * addr_size)
17369 {
17370 error (_(" Malformed note - too short for header\n"));
17371 return FALSE;
17372 }
17373
17374 descdata = (unsigned char *) pnote->descdata;
17375 descend = descdata + pnote->descsz;
17376
17377 if (descdata[pnote->descsz - 1] != '\0')
17378 {
17379 error (_(" Malformed note - does not end with \\0\n"));
17380 return FALSE;
17381 }
17382
17383 count = byte_get (descdata, addr_size);
17384 descdata += addr_size;
17385
17386 page_size = byte_get (descdata, addr_size);
17387 descdata += addr_size;
17388
17389 if (count > ((bfd_vma) -1 - 2 * addr_size) / (3 * addr_size)
17390 || pnote->descsz < 2 * addr_size + count * 3 * addr_size)
17391 {
17392 error (_(" Malformed note - too short for supplied file count\n"));
17393 return FALSE;
17394 }
17395
17396 printf (_(" Page size: "));
17397 print_vma (page_size, DEC);
17398 printf ("\n");
17399
17400 printf (_(" %*s%*s%*s\n"),
17401 (int) (2 + 2 * addr_size), _("Start"),
17402 (int) (4 + 2 * addr_size), _("End"),
17403 (int) (4 + 2 * addr_size), _("Page Offset"));
17404 filenames = descdata + count * 3 * addr_size;
17405 while (count-- > 0)
17406 {
17407 bfd_vma start, end, file_ofs;
17408
17409 if (filenames == descend)
17410 {
17411 error (_(" Malformed note - filenames end too early\n"));
17412 return FALSE;
17413 }
17414
17415 start = byte_get (descdata, addr_size);
17416 descdata += addr_size;
17417 end = byte_get (descdata, addr_size);
17418 descdata += addr_size;
17419 file_ofs = byte_get (descdata, addr_size);
17420 descdata += addr_size;
17421
17422 printf (" ");
17423 print_vma (start, FULL_HEX);
17424 printf (" ");
17425 print_vma (end, FULL_HEX);
17426 printf (" ");
17427 print_vma (file_ofs, FULL_HEX);
17428 printf ("\n %s\n", filenames);
17429
17430 filenames += 1 + strlen ((char *) filenames);
17431 }
17432
17433 return TRUE;
17434 }
17435
17436 static const char *
17437 get_gnu_elf_note_type (unsigned e_type)
17438 {
17439 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
17440 switch (e_type)
17441 {
17442 case NT_GNU_ABI_TAG:
17443 return _("NT_GNU_ABI_TAG (ABI version tag)");
17444 case NT_GNU_HWCAP:
17445 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17446 case NT_GNU_BUILD_ID:
17447 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17448 case NT_GNU_GOLD_VERSION:
17449 return _("NT_GNU_GOLD_VERSION (gold version)");
17450 case NT_GNU_PROPERTY_TYPE_0:
17451 return _("NT_GNU_PROPERTY_TYPE_0");
17452 case NT_GNU_BUILD_ATTRIBUTE_OPEN:
17453 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17454 case NT_GNU_BUILD_ATTRIBUTE_FUNC:
17455 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17456 default:
17457 {
17458 static char buff[64];
17459
17460 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17461 return buff;
17462 }
17463 }
17464 }
17465
17466 static void
17467 decode_x86_compat_isa (unsigned int bitmask)
17468 {
17469 while (bitmask)
17470 {
17471 unsigned int bit = bitmask & (- bitmask);
17472
17473 bitmask &= ~ bit;
17474 switch (bit)
17475 {
17476 case GNU_PROPERTY_X86_COMPAT_ISA_1_486:
17477 printf ("i486");
17478 break;
17479 case GNU_PROPERTY_X86_COMPAT_ISA_1_586:
17480 printf ("586");
17481 break;
17482 case GNU_PROPERTY_X86_COMPAT_ISA_1_686:
17483 printf ("686");
17484 break;
17485 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE:
17486 printf ("SSE");
17487 break;
17488 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2:
17489 printf ("SSE2");
17490 break;
17491 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3:
17492 printf ("SSE3");
17493 break;
17494 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3:
17495 printf ("SSSE3");
17496 break;
17497 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1:
17498 printf ("SSE4_1");
17499 break;
17500 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2:
17501 printf ("SSE4_2");
17502 break;
17503 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX:
17504 printf ("AVX");
17505 break;
17506 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2:
17507 printf ("AVX2");
17508 break;
17509 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F:
17510 printf ("AVX512F");
17511 break;
17512 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD:
17513 printf ("AVX512CD");
17514 break;
17515 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER:
17516 printf ("AVX512ER");
17517 break;
17518 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF:
17519 printf ("AVX512PF");
17520 break;
17521 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL:
17522 printf ("AVX512VL");
17523 break;
17524 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ:
17525 printf ("AVX512DQ");
17526 break;
17527 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW:
17528 printf ("AVX512BW");
17529 break;
17530 default:
17531 printf (_("<unknown: %x>"), bit);
17532 break;
17533 }
17534 if (bitmask)
17535 printf (", ");
17536 }
17537 }
17538
17539 static void
17540 decode_x86_isa (unsigned int bitmask)
17541 {
17542 if (!bitmask)
17543 {
17544 printf (_("<None>"));
17545 return;
17546 }
17547
17548 while (bitmask)
17549 {
17550 unsigned int bit = bitmask & (- bitmask);
17551
17552 bitmask &= ~ bit;
17553 switch (bit)
17554 {
17555 case GNU_PROPERTY_X86_ISA_1_CMOV:
17556 printf ("CMOV");
17557 break;
17558 case GNU_PROPERTY_X86_ISA_1_SSE:
17559 printf ("SSE");
17560 break;
17561 case GNU_PROPERTY_X86_ISA_1_SSE2:
17562 printf ("SSE2");
17563 break;
17564 case GNU_PROPERTY_X86_ISA_1_SSE3:
17565 printf ("SSE3");
17566 break;
17567 case GNU_PROPERTY_X86_ISA_1_SSSE3:
17568 printf ("SSSE3");
17569 break;
17570 case GNU_PROPERTY_X86_ISA_1_SSE4_1:
17571 printf ("SSE4_1");
17572 break;
17573 case GNU_PROPERTY_X86_ISA_1_SSE4_2:
17574 printf ("SSE4_2");
17575 break;
17576 case GNU_PROPERTY_X86_ISA_1_AVX:
17577 printf ("AVX");
17578 break;
17579 case GNU_PROPERTY_X86_ISA_1_AVX2:
17580 printf ("AVX2");
17581 break;
17582 case GNU_PROPERTY_X86_ISA_1_FMA:
17583 printf ("FMA");
17584 break;
17585 case GNU_PROPERTY_X86_ISA_1_AVX512F:
17586 printf ("AVX512F");
17587 break;
17588 case GNU_PROPERTY_X86_ISA_1_AVX512CD:
17589 printf ("AVX512CD");
17590 break;
17591 case GNU_PROPERTY_X86_ISA_1_AVX512ER:
17592 printf ("AVX512ER");
17593 break;
17594 case GNU_PROPERTY_X86_ISA_1_AVX512PF:
17595 printf ("AVX512PF");
17596 break;
17597 case GNU_PROPERTY_X86_ISA_1_AVX512VL:
17598 printf ("AVX512VL");
17599 break;
17600 case GNU_PROPERTY_X86_ISA_1_AVX512DQ:
17601 printf ("AVX512DQ");
17602 break;
17603 case GNU_PROPERTY_X86_ISA_1_AVX512BW:
17604 printf ("AVX512BW");
17605 break;
17606 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS:
17607 printf ("AVX512_4FMAPS");
17608 break;
17609 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW:
17610 printf ("AVX512_4VNNIW");
17611 break;
17612 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG:
17613 printf ("AVX512_BITALG");
17614 break;
17615 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA:
17616 printf ("AVX512_IFMA");
17617 break;
17618 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI:
17619 printf ("AVX512_VBMI");
17620 break;
17621 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2:
17622 printf ("AVX512_VBMI2");
17623 break;
17624 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI:
17625 printf ("AVX512_VNNI");
17626 break;
17627 case GNU_PROPERTY_X86_ISA_1_AVX512_BF16:
17628 printf ("AVX512_BF16");
17629 break;
17630 default:
17631 printf (_("<unknown: %x>"), bit);
17632 break;
17633 }
17634 if (bitmask)
17635 printf (", ");
17636 }
17637 }
17638
17639 static const char *
17640 get_amd_elf_note_type (unsigned e_type)
17641 {
17642 static char buff[64];
17643
17644 switch (e_type)
17645 {
17646 case NT_AMDGPU_HSA_CODE_OBJECT_VERSION:
17647 return _("NT_AMDGPU_HSA_CODE_OBJECT_VERSION (code object version)");
17648 case NT_AMDGPU_HSA_HSAIL:
17649 return _("NT_AMDGPU_HSA_HSAIL (hsail)");
17650 case NT_AMDGPU_HSA_ISA:
17651 return _("NT_AMDGPU_HSA_ISA (ISA name)");
17652 case NT_AMDGPU_HSA_PRODUCER:
17653 return _("NT_AMDGPU_HSA_PRODUCER (producer name)");
17654 case NT_AMDGPU_HSA_PRODUCER_OPTIONS:
17655 return _("NT_AMDGPU_HSA_PRODUCER_OPTIONS (producer options");
17656 case NT_AMDGPU_HSA_EXTENSION:
17657 return _("NT_AMDGPU_HSA_EXTENSION (extension)");
17658 case NT_AMDGPU_HSA_METADATA:
17659 return _("NT_AMDGPU_HSA_METADATA (code object metadata)");
17660 case NT_AMDGPU_ISA:
17661 return _("NT_AMDGPU_ISA");
17662 case NT_AMDGPU_PAL_METADATA:
17663 return _("NT_AMDGPU_PAL_METADATA (code object metadata)");
17664 case NT_AMDGPU_METADATA:
17665 return _("NT_AMDGPU_METADATA (code object metadata)");
17666 default:
17667 break;
17668 }
17669
17670 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17671 return buff;
17672 }
17673
17674 static int
17675 print_amd_note (Elf_Internal_Note *pnote)
17676 {
17677 switch (pnote->type)
17678 {
17679 case NT_AMDGPU_HSA_CODE_OBJECT_VERSION:
17680 {
17681 unsigned int major, minor;
17682
17683 major = byte_get ((unsigned char*) pnote->descdata, 4);
17684 minor = byte_get ((unsigned char*) pnote->descdata + 4, 4);
17685
17686 printf (_(" Version: %d.%d\n"), major, minor);
17687 }
17688 break;
17689
17690 case NT_AMDGPU_HSA_ISA:
17691 {
17692 unsigned long i, vendorsz;
17693 unsigned int major, minor, stepping;
17694
17695 vendorsz = byte_get ((unsigned char*) pnote->descdata, 2);
17696 major = byte_get ((unsigned char*) pnote->descdata + 4, 4);
17697 minor = byte_get ((unsigned char*) pnote->descdata + 8, 4);
17698 stepping = byte_get ((unsigned char*) pnote->descdata + 12, 4);
17699
17700 printf (_(" Vendor: "));
17701 for (i = 16; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
17702 printf ("%c", pnote->descdata[i]);
17703 printf (_(", Architecture: "));
17704 for (i = 16 + vendorsz; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
17705 printf ("%c", pnote->descdata[i]);
17706
17707 printf (_(", Version: %d.%d.%d"), major, minor, stepping);
17708 printf ("\n");
17709 }
17710 break;
17711 }
17712 return 1;
17713 }
17714
17715 static void
17716 decode_x86_feature_1 (unsigned int bitmask)
17717 {
17718 if (!bitmask)
17719 {
17720 printf (_("<None>"));
17721 return;
17722 }
17723
17724 while (bitmask)
17725 {
17726 unsigned int bit = bitmask & (- bitmask);
17727
17728 bitmask &= ~ bit;
17729 switch (bit)
17730 {
17731 case GNU_PROPERTY_X86_FEATURE_1_IBT:
17732 printf ("IBT");
17733 break;
17734 case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
17735 printf ("SHSTK");
17736 break;
17737 default:
17738 printf (_("<unknown: %x>"), bit);
17739 break;
17740 }
17741 if (bitmask)
17742 printf (", ");
17743 }
17744 }
17745
17746 static void
17747 decode_x86_feature_2 (unsigned int bitmask)
17748 {
17749 if (!bitmask)
17750 {
17751 printf (_("<None>"));
17752 return;
17753 }
17754
17755 while (bitmask)
17756 {
17757 unsigned int bit = bitmask & (- bitmask);
17758
17759 bitmask &= ~ bit;
17760 switch (bit)
17761 {
17762 case GNU_PROPERTY_X86_FEATURE_2_X86:
17763 printf ("x86");
17764 break;
17765 case GNU_PROPERTY_X86_FEATURE_2_X87:
17766 printf ("x87");
17767 break;
17768 case GNU_PROPERTY_X86_FEATURE_2_MMX:
17769 printf ("MMX");
17770 break;
17771 case GNU_PROPERTY_X86_FEATURE_2_XMM:
17772 printf ("XMM");
17773 break;
17774 case GNU_PROPERTY_X86_FEATURE_2_YMM:
17775 printf ("YMM");
17776 break;
17777 case GNU_PROPERTY_X86_FEATURE_2_ZMM:
17778 printf ("ZMM");
17779 break;
17780 case GNU_PROPERTY_X86_FEATURE_2_FXSR:
17781 printf ("FXSR");
17782 break;
17783 case GNU_PROPERTY_X86_FEATURE_2_XSAVE:
17784 printf ("XSAVE");
17785 break;
17786 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT:
17787 printf ("XSAVEOPT");
17788 break;
17789 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC:
17790 printf ("XSAVEC");
17791 break;
17792 default:
17793 printf (_("<unknown: %x>"), bit);
17794 break;
17795 }
17796 if (bitmask)
17797 printf (", ");
17798 }
17799 }
17800
17801 static void
17802 decode_aarch64_feature_1_and (unsigned int bitmask)
17803 {
17804 while (bitmask)
17805 {
17806 unsigned int bit = bitmask & (- bitmask);
17807
17808 bitmask &= ~ bit;
17809 switch (bit)
17810 {
17811 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI:
17812 printf ("BTI");
17813 break;
17814
17815 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC:
17816 printf ("PAC");
17817 break;
17818
17819 default:
17820 printf (_("<unknown: %x>"), bit);
17821 break;
17822 }
17823 if (bitmask)
17824 printf (", ");
17825 }
17826 }
17827
17828 static void
17829 print_gnu_property_note (Filedata * filedata, Elf_Internal_Note * pnote)
17830 {
17831 unsigned char * ptr = (unsigned char *) pnote->descdata;
17832 unsigned char * ptr_end = ptr + pnote->descsz;
17833 unsigned int size = is_32bit_elf ? 4 : 8;
17834
17835 printf (_(" Properties: "));
17836
17837 if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
17838 {
17839 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
17840 return;
17841 }
17842
17843 while (ptr < ptr_end)
17844 {
17845 unsigned int j;
17846 unsigned int type;
17847 unsigned int datasz;
17848
17849 if ((size_t) (ptr_end - ptr) < 8)
17850 {
17851 printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
17852 break;
17853 }
17854
17855 type = byte_get (ptr, 4);
17856 datasz = byte_get (ptr + 4, 4);
17857
17858 ptr += 8;
17859
17860 if (datasz > (size_t) (ptr_end - ptr))
17861 {
17862 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
17863 type, datasz);
17864 break;
17865 }
17866
17867 if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
17868 {
17869 if (filedata->file_header.e_machine == EM_X86_64
17870 || filedata->file_header.e_machine == EM_IAMCU
17871 || filedata->file_header.e_machine == EM_386)
17872 {
17873 unsigned int bitmask;
17874
17875 if (datasz == 4)
17876 bitmask = byte_get (ptr, 4);
17877 else
17878 bitmask = 0;
17879
17880 switch (type)
17881 {
17882 case GNU_PROPERTY_X86_ISA_1_USED:
17883 if (datasz != 4)
17884 printf (_("x86 ISA used: <corrupt length: %#x> "),
17885 datasz);
17886 else
17887 {
17888 printf ("x86 ISA used: ");
17889 decode_x86_isa (bitmask);
17890 }
17891 goto next;
17892
17893 case GNU_PROPERTY_X86_ISA_1_NEEDED:
17894 if (datasz != 4)
17895 printf (_("x86 ISA needed: <corrupt length: %#x> "),
17896 datasz);
17897 else
17898 {
17899 printf ("x86 ISA needed: ");
17900 decode_x86_isa (bitmask);
17901 }
17902 goto next;
17903
17904 case GNU_PROPERTY_X86_FEATURE_1_AND:
17905 if (datasz != 4)
17906 printf (_("x86 feature: <corrupt length: %#x> "),
17907 datasz);
17908 else
17909 {
17910 printf ("x86 feature: ");
17911 decode_x86_feature_1 (bitmask);
17912 }
17913 goto next;
17914
17915 case GNU_PROPERTY_X86_FEATURE_2_USED:
17916 if (datasz != 4)
17917 printf (_("x86 feature used: <corrupt length: %#x> "),
17918 datasz);
17919 else
17920 {
17921 printf ("x86 feature used: ");
17922 decode_x86_feature_2 (bitmask);
17923 }
17924 goto next;
17925
17926 case GNU_PROPERTY_X86_FEATURE_2_NEEDED:
17927 if (datasz != 4)
17928 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz);
17929 else
17930 {
17931 printf ("x86 feature needed: ");
17932 decode_x86_feature_2 (bitmask);
17933 }
17934 goto next;
17935
17936 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED:
17937 if (datasz != 4)
17938 printf (_("x86 ISA used: <corrupt length: %#x> "),
17939 datasz);
17940 else
17941 {
17942 printf ("x86 ISA used: ");
17943 decode_x86_compat_isa (bitmask);
17944 }
17945 goto next;
17946
17947 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED:
17948 if (datasz != 4)
17949 printf (_("x86 ISA needed: <corrupt length: %#x> "),
17950 datasz);
17951 else
17952 {
17953 printf ("x86 ISA needed: ");
17954 decode_x86_compat_isa (bitmask);
17955 }
17956 goto next;
17957
17958 default:
17959 break;
17960 }
17961 }
17962 else if (filedata->file_header.e_machine == EM_AARCH64)
17963 {
17964 if (type == GNU_PROPERTY_AARCH64_FEATURE_1_AND)
17965 {
17966 printf ("AArch64 feature: ");
17967 if (datasz != 4)
17968 printf (_("<corrupt length: %#x> "), datasz);
17969 else
17970 decode_aarch64_feature_1_and (byte_get (ptr, 4));
17971 goto next;
17972 }
17973 }
17974 }
17975 else
17976 {
17977 switch (type)
17978 {
17979 case GNU_PROPERTY_STACK_SIZE:
17980 printf (_("stack size: "));
17981 if (datasz != size)
17982 printf (_("<corrupt length: %#x> "), datasz);
17983 else
17984 printf ("%#lx", (unsigned long) byte_get (ptr, size));
17985 goto next;
17986
17987 case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
17988 printf ("no copy on protected ");
17989 if (datasz)
17990 printf (_("<corrupt length: %#x> "), datasz);
17991 goto next;
17992
17993 default:
17994 break;
17995 }
17996 }
17997
17998 if (type < GNU_PROPERTY_LOPROC)
17999 printf (_("<unknown type %#x data: "), type);
18000 else if (type < GNU_PROPERTY_LOUSER)
18001 printf (_("<procesor-specific type %#x data: "), type);
18002 else
18003 printf (_("<application-specific type %#x data: "), type);
18004 for (j = 0; j < datasz; ++j)
18005 printf ("%02x ", ptr[j] & 0xff);
18006 printf (">");
18007
18008 next:
18009 ptr += ((datasz + (size - 1)) & ~ (size - 1));
18010 if (ptr == ptr_end)
18011 break;
18012
18013 if (do_wide)
18014 printf (", ");
18015 else
18016 printf ("\n\t");
18017 }
18018
18019 printf ("\n");
18020 }
18021
18022 static bfd_boolean
18023 print_gnu_note (Filedata * filedata, Elf_Internal_Note *pnote)
18024 {
18025 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
18026 switch (pnote->type)
18027 {
18028 case NT_GNU_BUILD_ID:
18029 {
18030 unsigned long i;
18031
18032 printf (_(" Build ID: "));
18033 for (i = 0; i < pnote->descsz; ++i)
18034 printf ("%02x", pnote->descdata[i] & 0xff);
18035 printf ("\n");
18036 }
18037 break;
18038
18039 case NT_GNU_ABI_TAG:
18040 {
18041 unsigned long os, major, minor, subminor;
18042 const char *osname;
18043
18044 /* PR 17531: file: 030-599401-0.004. */
18045 if (pnote->descsz < 16)
18046 {
18047 printf (_(" <corrupt GNU_ABI_TAG>\n"));
18048 break;
18049 }
18050
18051 os = byte_get ((unsigned char *) pnote->descdata, 4);
18052 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
18053 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
18054 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
18055
18056 switch (os)
18057 {
18058 case GNU_ABI_TAG_LINUX:
18059 osname = "Linux";
18060 break;
18061 case GNU_ABI_TAG_HURD:
18062 osname = "Hurd";
18063 break;
18064 case GNU_ABI_TAG_SOLARIS:
18065 osname = "Solaris";
18066 break;
18067 case GNU_ABI_TAG_FREEBSD:
18068 osname = "FreeBSD";
18069 break;
18070 case GNU_ABI_TAG_NETBSD:
18071 osname = "NetBSD";
18072 break;
18073 case GNU_ABI_TAG_SYLLABLE:
18074 osname = "Syllable";
18075 break;
18076 case GNU_ABI_TAG_NACL:
18077 osname = "NaCl";
18078 break;
18079 default:
18080 osname = "Unknown";
18081 break;
18082 }
18083
18084 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
18085 major, minor, subminor);
18086 }
18087 break;
18088
18089 case NT_GNU_GOLD_VERSION:
18090 {
18091 unsigned long i;
18092
18093 printf (_(" Version: "));
18094 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
18095 printf ("%c", pnote->descdata[i]);
18096 printf ("\n");
18097 }
18098 break;
18099
18100 case NT_GNU_HWCAP:
18101 {
18102 unsigned long num_entries, mask;
18103
18104 /* Hardware capabilities information. Word 0 is the number of entries.
18105 Word 1 is a bitmask of enabled entries. The rest of the descriptor
18106 is a series of entries, where each entry is a single byte followed
18107 by a nul terminated string. The byte gives the bit number to test
18108 if enabled in the bitmask. */
18109 printf (_(" Hardware Capabilities: "));
18110 if (pnote->descsz < 8)
18111 {
18112 error (_("<corrupt GNU_HWCAP>\n"));
18113 return FALSE;
18114 }
18115 num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
18116 mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
18117 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
18118 /* FIXME: Add code to display the entries... */
18119 }
18120 break;
18121
18122 case NT_GNU_PROPERTY_TYPE_0:
18123 print_gnu_property_note (filedata, pnote);
18124 break;
18125
18126 default:
18127 /* Handle unrecognised types. An error message should have already been
18128 created by get_gnu_elf_note_type(), so all that we need to do is to
18129 display the data. */
18130 {
18131 unsigned long i;
18132
18133 printf (_(" Description data: "));
18134 for (i = 0; i < pnote->descsz; ++i)
18135 printf ("%02x ", pnote->descdata[i] & 0xff);
18136 printf ("\n");
18137 }
18138 break;
18139 }
18140
18141 return TRUE;
18142 }
18143
18144 static const char *
18145 get_v850_elf_note_type (enum v850_notes n_type)
18146 {
18147 static char buff[64];
18148
18149 switch (n_type)
18150 {
18151 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
18152 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
18153 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
18154 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
18155 case V850_NOTE_CACHE_INFO: return _("Use of cache");
18156 case V850_NOTE_MMU_INFO: return _("Use of MMU");
18157 default:
18158 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
18159 return buff;
18160 }
18161 }
18162
18163 static bfd_boolean
18164 print_v850_note (Elf_Internal_Note * pnote)
18165 {
18166 unsigned int val;
18167
18168 if (pnote->descsz != 4)
18169 return FALSE;
18170
18171 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
18172
18173 if (val == 0)
18174 {
18175 printf (_("not set\n"));
18176 return TRUE;
18177 }
18178
18179 switch (pnote->type)
18180 {
18181 case V850_NOTE_ALIGNMENT:
18182 switch (val)
18183 {
18184 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
18185 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
18186 }
18187 break;
18188
18189 case V850_NOTE_DATA_SIZE:
18190 switch (val)
18191 {
18192 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
18193 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
18194 }
18195 break;
18196
18197 case V850_NOTE_FPU_INFO:
18198 switch (val)
18199 {
18200 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
18201 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
18202 }
18203 break;
18204
18205 case V850_NOTE_MMU_INFO:
18206 case V850_NOTE_CACHE_INFO:
18207 case V850_NOTE_SIMD_INFO:
18208 if (val == EF_RH850_SIMD)
18209 {
18210 printf (_("yes\n"));
18211 return TRUE;
18212 }
18213 break;
18214
18215 default:
18216 /* An 'unknown note type' message will already have been displayed. */
18217 break;
18218 }
18219
18220 printf (_("unknown value: %x\n"), val);
18221 return FALSE;
18222 }
18223
18224 static bfd_boolean
18225 process_netbsd_elf_note (Elf_Internal_Note * pnote)
18226 {
18227 unsigned int version;
18228
18229 switch (pnote->type)
18230 {
18231 case NT_NETBSD_IDENT:
18232 version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
18233 if ((version / 10000) % 100)
18234 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
18235 version, version / 100000000, (version / 1000000) % 100,
18236 (version / 10000) % 100 > 26 ? "Z" : "",
18237 'A' + (version / 10000) % 26);
18238 else
18239 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
18240 version, version / 100000000, (version / 1000000) % 100,
18241 (version / 100) % 100);
18242 return TRUE;
18243
18244 case NT_NETBSD_MARCH:
18245 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
18246 pnote->descdata);
18247 return TRUE;
18248
18249 #ifdef NT_NETBSD_PAX
18250 case NT_NETBSD_PAX:
18251 version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
18252 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote->descsz,
18253 ((version & NT_NETBSD_PAX_MPROTECT) ? "+mprotect" : ""),
18254 ((version & NT_NETBSD_PAX_NOMPROTECT) ? "-mprotect" : ""),
18255 ((version & NT_NETBSD_PAX_GUARD) ? "+guard" : ""),
18256 ((version & NT_NETBSD_PAX_NOGUARD) ? "-guard" : ""),
18257 ((version & NT_NETBSD_PAX_ASLR) ? "+ASLR" : ""),
18258 ((version & NT_NETBSD_PAX_NOASLR) ? "-ASLR" : ""));
18259 return TRUE;
18260 #endif
18261
18262 default:
18263 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
18264 pnote->type);
18265 return FALSE;
18266 }
18267 }
18268
18269 static const char *
18270 get_freebsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
18271 {
18272 switch (e_type)
18273 {
18274 case NT_FREEBSD_THRMISC:
18275 return _("NT_THRMISC (thrmisc structure)");
18276 case NT_FREEBSD_PROCSTAT_PROC:
18277 return _("NT_PROCSTAT_PROC (proc data)");
18278 case NT_FREEBSD_PROCSTAT_FILES:
18279 return _("NT_PROCSTAT_FILES (files data)");
18280 case NT_FREEBSD_PROCSTAT_VMMAP:
18281 return _("NT_PROCSTAT_VMMAP (vmmap data)");
18282 case NT_FREEBSD_PROCSTAT_GROUPS:
18283 return _("NT_PROCSTAT_GROUPS (groups data)");
18284 case NT_FREEBSD_PROCSTAT_UMASK:
18285 return _("NT_PROCSTAT_UMASK (umask data)");
18286 case NT_FREEBSD_PROCSTAT_RLIMIT:
18287 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18288 case NT_FREEBSD_PROCSTAT_OSREL:
18289 return _("NT_PROCSTAT_OSREL (osreldate data)");
18290 case NT_FREEBSD_PROCSTAT_PSSTRINGS:
18291 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18292 case NT_FREEBSD_PROCSTAT_AUXV:
18293 return _("NT_PROCSTAT_AUXV (auxv data)");
18294 case NT_FREEBSD_PTLWPINFO:
18295 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18296 }
18297 return get_note_type (filedata, e_type);
18298 }
18299
18300 static const char *
18301 get_netbsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
18302 {
18303 static char buff[64];
18304
18305 switch (e_type)
18306 {
18307 case NT_NETBSDCORE_PROCINFO:
18308 /* NetBSD core "procinfo" structure. */
18309 return _("NetBSD procinfo structure");
18310
18311 #ifdef NT_NETBSDCORE_AUXV
18312 case NT_NETBSDCORE_AUXV:
18313 return _("NetBSD ELF auxiliary vector data");
18314 #endif
18315
18316 default:
18317 /* As of Jan 2002 there are no other machine-independent notes
18318 defined for NetBSD core files. If the note type is less
18319 than the start of the machine-dependent note types, we don't
18320 understand it. */
18321
18322 if (e_type < NT_NETBSDCORE_FIRSTMACH)
18323 {
18324 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
18325 return buff;
18326 }
18327 break;
18328 }
18329
18330 switch (filedata->file_header.e_machine)
18331 {
18332 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18333 and PT_GETFPREGS == mach+2. */
18334
18335 case EM_OLD_ALPHA:
18336 case EM_ALPHA:
18337 case EM_SPARC:
18338 case EM_SPARC32PLUS:
18339 case EM_SPARCV9:
18340 switch (e_type)
18341 {
18342 case NT_NETBSDCORE_FIRSTMACH + 0:
18343 return _("PT_GETREGS (reg structure)");
18344 case NT_NETBSDCORE_FIRSTMACH + 2:
18345 return _("PT_GETFPREGS (fpreg structure)");
18346 default:
18347 break;
18348 }
18349 break;
18350
18351 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
18352 There's also old PT___GETREGS40 == mach + 1 for old reg
18353 structure which lacks GBR. */
18354 case EM_SH:
18355 switch (e_type)
18356 {
18357 case NT_NETBSDCORE_FIRSTMACH + 1:
18358 return _("PT___GETREGS40 (old reg structure)");
18359 case NT_NETBSDCORE_FIRSTMACH + 3:
18360 return _("PT_GETREGS (reg structure)");
18361 case NT_NETBSDCORE_FIRSTMACH + 5:
18362 return _("PT_GETFPREGS (fpreg structure)");
18363 default:
18364 break;
18365 }
18366 break;
18367
18368 /* On all other arch's, PT_GETREGS == mach+1 and
18369 PT_GETFPREGS == mach+3. */
18370 default:
18371 switch (e_type)
18372 {
18373 case NT_NETBSDCORE_FIRSTMACH + 1:
18374 return _("PT_GETREGS (reg structure)");
18375 case NT_NETBSDCORE_FIRSTMACH + 3:
18376 return _("PT_GETFPREGS (fpreg structure)");
18377 default:
18378 break;
18379 }
18380 }
18381
18382 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
18383 e_type - NT_NETBSDCORE_FIRSTMACH);
18384 return buff;
18385 }
18386
18387 static const char *
18388 get_stapsdt_note_type (unsigned e_type)
18389 {
18390 static char buff[64];
18391
18392 switch (e_type)
18393 {
18394 case NT_STAPSDT:
18395 return _("NT_STAPSDT (SystemTap probe descriptors)");
18396
18397 default:
18398 break;
18399 }
18400
18401 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
18402 return buff;
18403 }
18404
18405 static bfd_boolean
18406 print_stapsdt_note (Elf_Internal_Note *pnote)
18407 {
18408 size_t len, maxlen;
18409 unsigned long addr_size = is_32bit_elf ? 4 : 8;
18410 char *data = pnote->descdata;
18411 char *data_end = pnote->descdata + pnote->descsz;
18412 bfd_vma pc, base_addr, semaphore;
18413 char *provider, *probe, *arg_fmt;
18414
18415 if (pnote->descsz < (addr_size * 3))
18416 goto stapdt_note_too_small;
18417
18418 pc = byte_get ((unsigned char *) data, addr_size);
18419 data += addr_size;
18420
18421 base_addr = byte_get ((unsigned char *) data, addr_size);
18422 data += addr_size;
18423
18424 semaphore = byte_get ((unsigned char *) data, addr_size);
18425 data += addr_size;
18426
18427 if (data >= data_end)
18428 goto stapdt_note_too_small;
18429 maxlen = data_end - data;
18430 len = strnlen (data, maxlen);
18431 if (len < maxlen)
18432 {
18433 provider = data;
18434 data += len + 1;
18435 }
18436 else
18437 goto stapdt_note_too_small;
18438
18439 if (data >= data_end)
18440 goto stapdt_note_too_small;
18441 maxlen = data_end - data;
18442 len = strnlen (data, maxlen);
18443 if (len < maxlen)
18444 {
18445 probe = data;
18446 data += len + 1;
18447 }
18448 else
18449 goto stapdt_note_too_small;
18450
18451 if (data >= data_end)
18452 goto stapdt_note_too_small;
18453 maxlen = data_end - data;
18454 len = strnlen (data, maxlen);
18455 if (len < maxlen)
18456 {
18457 arg_fmt = data;
18458 data += len + 1;
18459 }
18460 else
18461 goto stapdt_note_too_small;
18462
18463 printf (_(" Provider: %s\n"), provider);
18464 printf (_(" Name: %s\n"), probe);
18465 printf (_(" Location: "));
18466 print_vma (pc, FULL_HEX);
18467 printf (_(", Base: "));
18468 print_vma (base_addr, FULL_HEX);
18469 printf (_(", Semaphore: "));
18470 print_vma (semaphore, FULL_HEX);
18471 printf ("\n");
18472 printf (_(" Arguments: %s\n"), arg_fmt);
18473
18474 return data == data_end;
18475
18476 stapdt_note_too_small:
18477 printf (_(" <corrupt - note is too small>\n"));
18478 error (_("corrupt stapdt note - the data size is too small\n"));
18479 return FALSE;
18480 }
18481
18482 static const char *
18483 get_ia64_vms_note_type (unsigned e_type)
18484 {
18485 static char buff[64];
18486
18487 switch (e_type)
18488 {
18489 case NT_VMS_MHD:
18490 return _("NT_VMS_MHD (module header)");
18491 case NT_VMS_LNM:
18492 return _("NT_VMS_LNM (language name)");
18493 case NT_VMS_SRC:
18494 return _("NT_VMS_SRC (source files)");
18495 case NT_VMS_TITLE:
18496 return "NT_VMS_TITLE";
18497 case NT_VMS_EIDC:
18498 return _("NT_VMS_EIDC (consistency check)");
18499 case NT_VMS_FPMODE:
18500 return _("NT_VMS_FPMODE (FP mode)");
18501 case NT_VMS_LINKTIME:
18502 return "NT_VMS_LINKTIME";
18503 case NT_VMS_IMGNAM:
18504 return _("NT_VMS_IMGNAM (image name)");
18505 case NT_VMS_IMGID:
18506 return _("NT_VMS_IMGID (image id)");
18507 case NT_VMS_LINKID:
18508 return _("NT_VMS_LINKID (link id)");
18509 case NT_VMS_IMGBID:
18510 return _("NT_VMS_IMGBID (build id)");
18511 case NT_VMS_GSTNAM:
18512 return _("NT_VMS_GSTNAM (sym table name)");
18513 case NT_VMS_ORIG_DYN:
18514 return "NT_VMS_ORIG_DYN";
18515 case NT_VMS_PATCHTIME:
18516 return "NT_VMS_PATCHTIME";
18517 default:
18518 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
18519 return buff;
18520 }
18521 }
18522
18523 static bfd_boolean
18524 print_ia64_vms_note (Elf_Internal_Note * pnote)
18525 {
18526 int maxlen = pnote->descsz;
18527
18528 if (maxlen < 2 || (unsigned long) maxlen != pnote->descsz)
18529 goto desc_size_fail;
18530
18531 switch (pnote->type)
18532 {
18533 case NT_VMS_MHD:
18534 if (maxlen <= 36)
18535 goto desc_size_fail;
18536
18537 int l = (int) strnlen (pnote->descdata + 34, maxlen - 34);
18538
18539 printf (_(" Creation date : %.17s\n"), pnote->descdata);
18540 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
18541 if (l + 34 < maxlen)
18542 {
18543 printf (_(" Module name : %s\n"), pnote->descdata + 34);
18544 if (l + 35 < maxlen)
18545 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
18546 else
18547 printf (_(" Module version : <missing>\n"));
18548 }
18549 else
18550 {
18551 printf (_(" Module name : <missing>\n"));
18552 printf (_(" Module version : <missing>\n"));
18553 }
18554 break;
18555
18556 case NT_VMS_LNM:
18557 printf (_(" Language: %.*s\n"), maxlen, pnote->descdata);
18558 break;
18559
18560 #ifdef BFD64
18561 case NT_VMS_FPMODE:
18562 printf (_(" Floating Point mode: "));
18563 if (maxlen < 8)
18564 goto desc_size_fail;
18565 /* FIXME: Generate an error if descsz > 8 ? */
18566
18567 printf ("0x%016" BFD_VMA_FMT "x\n",
18568 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
18569 break;
18570
18571 case NT_VMS_LINKTIME:
18572 printf (_(" Link time: "));
18573 if (maxlen < 8)
18574 goto desc_size_fail;
18575 /* FIXME: Generate an error if descsz > 8 ? */
18576
18577 print_vms_time
18578 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
18579 printf ("\n");
18580 break;
18581
18582 case NT_VMS_PATCHTIME:
18583 printf (_(" Patch time: "));
18584 if (maxlen < 8)
18585 goto desc_size_fail;
18586 /* FIXME: Generate an error if descsz > 8 ? */
18587
18588 print_vms_time
18589 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
18590 printf ("\n");
18591 break;
18592
18593 case NT_VMS_ORIG_DYN:
18594 if (maxlen < 34)
18595 goto desc_size_fail;
18596
18597 printf (_(" Major id: %u, minor id: %u\n"),
18598 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
18599 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
18600 printf (_(" Last modified : "));
18601 print_vms_time
18602 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
18603 printf (_("\n Link flags : "));
18604 printf ("0x%016" BFD_VMA_FMT "x\n",
18605 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
18606 printf (_(" Header flags: 0x%08x\n"),
18607 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
18608 printf (_(" Image id : %.*s\n"), maxlen - 32, pnote->descdata + 32);
18609 break;
18610 #endif
18611
18612 case NT_VMS_IMGNAM:
18613 printf (_(" Image name: %.*s\n"), maxlen, pnote->descdata);
18614 break;
18615
18616 case NT_VMS_GSTNAM:
18617 printf (_(" Global symbol table name: %.*s\n"), maxlen, pnote->descdata);
18618 break;
18619
18620 case NT_VMS_IMGID:
18621 printf (_(" Image id: %.*s\n"), maxlen, pnote->descdata);
18622 break;
18623
18624 case NT_VMS_LINKID:
18625 printf (_(" Linker id: %.*s\n"), maxlen, pnote->descdata);
18626 break;
18627
18628 default:
18629 return FALSE;
18630 }
18631
18632 return TRUE;
18633
18634 desc_size_fail:
18635 printf (_(" <corrupt - data size is too small>\n"));
18636 error (_("corrupt IA64 note: data size is too small\n"));
18637 return FALSE;
18638 }
18639
18640 /* Find the symbol associated with a build attribute that is attached
18641 to address OFFSET. If PNAME is non-NULL then store the name of
18642 the symbol (if found) in the provided pointer, Returns NULL if a
18643 symbol could not be found. */
18644
18645 static Elf_Internal_Sym *
18646 get_symbol_for_build_attribute (Filedata * filedata,
18647 unsigned long offset,
18648 bfd_boolean is_open_attr,
18649 const char ** pname)
18650 {
18651 static Filedata * saved_filedata = NULL;
18652 static char * strtab;
18653 static unsigned long strtablen;
18654 static Elf_Internal_Sym * symtab;
18655 static unsigned long nsyms;
18656 Elf_Internal_Sym * saved_sym = NULL;
18657 Elf_Internal_Sym * sym;
18658
18659 if (filedata->section_headers != NULL
18660 && (saved_filedata == NULL || filedata != saved_filedata))
18661 {
18662 Elf_Internal_Shdr * symsec;
18663
18664 /* Load the symbol and string sections. */
18665 for (symsec = filedata->section_headers;
18666 symsec < filedata->section_headers + filedata->file_header.e_shnum;
18667 symsec ++)
18668 {
18669 if (symsec->sh_type == SHT_SYMTAB)
18670 {
18671 symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
18672
18673 if (symsec->sh_link < filedata->file_header.e_shnum)
18674 {
18675 Elf_Internal_Shdr * strtab_sec = filedata->section_headers + symsec->sh_link;
18676
18677 strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
18678 1, strtab_sec->sh_size,
18679 _("string table"));
18680 strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
18681 }
18682 }
18683 }
18684 saved_filedata = filedata;
18685 }
18686
18687 if (symtab == NULL || strtab == NULL)
18688 return NULL;
18689
18690 /* Find a symbol whose value matches offset. */
18691 for (sym = symtab; sym < symtab + nsyms; sym ++)
18692 if (sym->st_value == offset)
18693 {
18694 if (sym->st_name >= strtablen)
18695 /* Huh ? This should not happen. */
18696 continue;
18697
18698 if (strtab[sym->st_name] == 0)
18699 continue;
18700
18701 /* The AArch64 and ARM architectures define mapping symbols
18702 (eg $d, $x, $t) which we want to ignore. */
18703 if (strtab[sym->st_name] == '$'
18704 && strtab[sym->st_name + 1] != 0
18705 && strtab[sym->st_name + 2] == 0)
18706 continue;
18707
18708 if (is_open_attr)
18709 {
18710 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
18711 and FILE or OBJECT symbols over NOTYPE symbols. We skip
18712 FUNC symbols entirely. */
18713 switch (ELF_ST_TYPE (sym->st_info))
18714 {
18715 case STT_OBJECT:
18716 case STT_FILE:
18717 saved_sym = sym;
18718 if (sym->st_size)
18719 {
18720 /* If the symbol has a size associated
18721 with it then we can stop searching. */
18722 sym = symtab + nsyms;
18723 }
18724 continue;
18725
18726 case STT_FUNC:
18727 /* Ignore function symbols. */
18728 continue;
18729
18730 default:
18731 break;
18732 }
18733
18734 switch (ELF_ST_BIND (sym->st_info))
18735 {
18736 case STB_GLOBAL:
18737 if (saved_sym == NULL
18738 || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
18739 saved_sym = sym;
18740 break;
18741
18742 case STB_LOCAL:
18743 if (saved_sym == NULL)
18744 saved_sym = sym;
18745 break;
18746
18747 default:
18748 break;
18749 }
18750 }
18751 else
18752 {
18753 if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
18754 continue;
18755
18756 saved_sym = sym;
18757 break;
18758 }
18759 }
18760
18761 if (saved_sym && pname)
18762 * pname = strtab + saved_sym->st_name;
18763
18764 return saved_sym;
18765 }
18766
18767 /* Returns true iff addr1 and addr2 are in the same section. */
18768
18769 static bfd_boolean
18770 same_section (Filedata * filedata, unsigned long addr1, unsigned long addr2)
18771 {
18772 Elf_Internal_Shdr * a1;
18773 Elf_Internal_Shdr * a2;
18774
18775 a1 = find_section_by_address (filedata, addr1);
18776 a2 = find_section_by_address (filedata, addr2);
18777
18778 return a1 == a2 && a1 != NULL;
18779 }
18780
18781 static bfd_boolean
18782 print_gnu_build_attribute_description (Elf_Internal_Note * pnote,
18783 Filedata * filedata)
18784 {
18785 static unsigned long global_offset = 0;
18786 static unsigned long global_end = 0;
18787 static unsigned long func_offset = 0;
18788 static unsigned long func_end = 0;
18789
18790 Elf_Internal_Sym * sym;
18791 const char * name;
18792 unsigned long start;
18793 unsigned long end;
18794 bfd_boolean is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
18795
18796 switch (pnote->descsz)
18797 {
18798 case 0:
18799 /* A zero-length description means that the range of
18800 the previous note of the same type should be used. */
18801 if (is_open_attr)
18802 {
18803 if (global_end > global_offset)
18804 printf (_(" Applies to region from %#lx to %#lx\n"),
18805 global_offset, global_end);
18806 else
18807 printf (_(" Applies to region from %#lx\n"), global_offset);
18808 }
18809 else
18810 {
18811 if (func_end > func_offset)
18812 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset, func_end);
18813 else
18814 printf (_(" Applies to region from %#lx\n"), func_offset);
18815 }
18816 return TRUE;
18817
18818 case 4:
18819 start = byte_get ((unsigned char *) pnote->descdata, 4);
18820 end = 0;
18821 break;
18822
18823 case 8:
18824 if (is_32bit_elf)
18825 {
18826 /* FIXME: We should check that version 3+ notes are being used here... */
18827 start = byte_get ((unsigned char *) pnote->descdata, 4);
18828 end = byte_get ((unsigned char *) pnote->descdata + 4, 4);
18829 }
18830 else
18831 {
18832 start = byte_get ((unsigned char *) pnote->descdata, 8);
18833 end = 0;
18834 }
18835 break;
18836
18837 case 16:
18838 start = byte_get ((unsigned char *) pnote->descdata, 8);
18839 end = byte_get ((unsigned char *) pnote->descdata + 8, 8);
18840 break;
18841
18842 default:
18843 error (_(" <invalid description size: %lx>\n"), pnote->descsz);
18844 printf (_(" <invalid descsz>"));
18845 return FALSE;
18846 }
18847
18848 name = NULL;
18849 sym = get_symbol_for_build_attribute (filedata, start, is_open_attr, & name);
18850 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
18851 in order to avoid them being confused with the start address of the
18852 first function in the file... */
18853 if (sym == NULL && is_open_attr)
18854 sym = get_symbol_for_build_attribute (filedata, start + 2, is_open_attr,
18855 & name);
18856
18857 if (end == 0 && sym != NULL && sym->st_size > 0)
18858 end = start + sym->st_size;
18859
18860 if (is_open_attr)
18861 {
18862 /* FIXME: Need to properly allow for section alignment.
18863 16 is just the alignment used on x86_64. */
18864 if (global_end > 0
18865 && start > BFD_ALIGN (global_end, 16)
18866 /* Build notes are not guaranteed to be organised in order of
18867 increasing address, but we should find the all of the notes
18868 for one section in the same place. */
18869 && same_section (filedata, start, global_end))
18870 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
18871 global_end + 1, start - 1);
18872
18873 printf (_(" Applies to region from %#lx"), start);
18874 global_offset = start;
18875
18876 if (end)
18877 {
18878 printf (_(" to %#lx"), end);
18879 global_end = end;
18880 }
18881 }
18882 else
18883 {
18884 printf (_(" Applies to region from %#lx"), start);
18885 func_offset = start;
18886
18887 if (end)
18888 {
18889 printf (_(" to %#lx"), end);
18890 func_end = end;
18891 }
18892 }
18893
18894 if (sym && name)
18895 printf (_(" (%s)"), name);
18896
18897 printf ("\n");
18898 return TRUE;
18899 }
18900
18901 static bfd_boolean
18902 print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
18903 {
18904 static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
18905 static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
18906 static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
18907 char name_type;
18908 char name_attribute;
18909 const char * expected_types;
18910 const char * name = pnote->namedata;
18911 const char * text;
18912 signed int left;
18913
18914 if (name == NULL || pnote->namesz < 2)
18915 {
18916 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
18917 print_symbol (-20, _(" <corrupt name>"));
18918 return FALSE;
18919 }
18920
18921 if (do_wide)
18922 left = 28;
18923 else
18924 left = 20;
18925
18926 /* Version 2 of the spec adds a "GA" prefix to the name field. */
18927 if (name[0] == 'G' && name[1] == 'A')
18928 {
18929 if (pnote->namesz < 4)
18930 {
18931 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
18932 print_symbol (-20, _(" <corrupt name>"));
18933 return FALSE;
18934 }
18935
18936 printf ("GA");
18937 name += 2;
18938 left -= 2;
18939 }
18940
18941 switch ((name_type = * name))
18942 {
18943 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
18944 case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
18945 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
18946 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
18947 printf ("%c", * name);
18948 left --;
18949 break;
18950 default:
18951 error (_("unrecognised attribute type in name field: %d\n"), name_type);
18952 print_symbol (-20, _("<unknown name type>"));
18953 return FALSE;
18954 }
18955
18956 ++ name;
18957 text = NULL;
18958
18959 switch ((name_attribute = * name))
18960 {
18961 case GNU_BUILD_ATTRIBUTE_VERSION:
18962 text = _("<version>");
18963 expected_types = string_expected;
18964 ++ name;
18965 break;
18966 case GNU_BUILD_ATTRIBUTE_STACK_PROT:
18967 text = _("<stack prot>");
18968 expected_types = "!+*";
18969 ++ name;
18970 break;
18971 case GNU_BUILD_ATTRIBUTE_RELRO:
18972 text = _("<relro>");
18973 expected_types = bool_expected;
18974 ++ name;
18975 break;
18976 case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
18977 text = _("<stack size>");
18978 expected_types = number_expected;
18979 ++ name;
18980 break;
18981 case GNU_BUILD_ATTRIBUTE_TOOL:
18982 text = _("<tool>");
18983 expected_types = string_expected;
18984 ++ name;
18985 break;
18986 case GNU_BUILD_ATTRIBUTE_ABI:
18987 text = _("<ABI>");
18988 expected_types = "$*";
18989 ++ name;
18990 break;
18991 case GNU_BUILD_ATTRIBUTE_PIC:
18992 text = _("<PIC>");
18993 expected_types = number_expected;
18994 ++ name;
18995 break;
18996 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
18997 text = _("<short enum>");
18998 expected_types = bool_expected;
18999 ++ name;
19000 break;
19001 default:
19002 if (ISPRINT (* name))
19003 {
19004 int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
19005
19006 if (len > left && ! do_wide)
19007 len = left;
19008 printf ("%.*s:", len, name);
19009 left -= len;
19010 name += len;
19011 }
19012 else
19013 {
19014 static char tmpbuf [128];
19015
19016 error (_("unrecognised byte in name field: %d\n"), * name);
19017 sprintf (tmpbuf, _("<unknown:_%d>"), * name);
19018 text = tmpbuf;
19019 name ++;
19020 }
19021 expected_types = "*$!+";
19022 break;
19023 }
19024
19025 if (text)
19026 left -= printf ("%s", text);
19027
19028 if (strchr (expected_types, name_type) == NULL)
19029 warn (_("attribute does not have an expected type (%c)\n"), name_type);
19030
19031 if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
19032 {
19033 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
19034 (unsigned long) pnote->namesz,
19035 (long) (name - pnote->namedata));
19036 return FALSE;
19037 }
19038
19039 if (left < 1 && ! do_wide)
19040 return TRUE;
19041
19042 switch (name_type)
19043 {
19044 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
19045 {
19046 unsigned int bytes;
19047 unsigned long long val = 0;
19048 unsigned int shift = 0;
19049 char * decoded = NULL;
19050
19051 bytes = pnote->namesz - (name - pnote->namedata);
19052 if (bytes > 0)
19053 /* The -1 is because the name field is always 0 terminated, and we
19054 want to be able to ensure that the shift in the while loop below
19055 will not overflow. */
19056 -- bytes;
19057
19058 if (bytes > sizeof (val))
19059 {
19060 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
19061 bytes);
19062 bytes = sizeof (val);
19063 }
19064 /* We do not bother to warn if bytes == 0 as this can
19065 happen with some early versions of the gcc plugin. */
19066
19067 while (bytes --)
19068 {
19069 unsigned long byte = (* name ++) & 0xff;
19070
19071 val |= byte << shift;
19072 shift += 8;
19073 }
19074
19075 switch (name_attribute)
19076 {
19077 case GNU_BUILD_ATTRIBUTE_PIC:
19078 switch (val)
19079 {
19080 case 0: decoded = "static"; break;
19081 case 1: decoded = "pic"; break;
19082 case 2: decoded = "PIC"; break;
19083 case 3: decoded = "pie"; break;
19084 case 4: decoded = "PIE"; break;
19085 default: break;
19086 }
19087 break;
19088 case GNU_BUILD_ATTRIBUTE_STACK_PROT:
19089 switch (val)
19090 {
19091 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
19092 case 0: decoded = "off"; break;
19093 case 1: decoded = "on"; break;
19094 case 2: decoded = "all"; break;
19095 case 3: decoded = "strong"; break;
19096 case 4: decoded = "explicit"; break;
19097 default: break;
19098 }
19099 break;
19100 default:
19101 break;
19102 }
19103
19104 if (decoded != NULL)
19105 {
19106 print_symbol (-left, decoded);
19107 left = 0;
19108 }
19109 else if (val == 0)
19110 {
19111 printf ("0x0");
19112 left -= 3;
19113 }
19114 else
19115 {
19116 if (do_wide)
19117 left -= printf ("0x%llx", val);
19118 else
19119 left -= printf ("0x%-.*llx", left, val);
19120 }
19121 }
19122 break;
19123 case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
19124 left -= print_symbol (- left, name);
19125 break;
19126 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
19127 left -= print_symbol (- left, "true");
19128 break;
19129 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
19130 left -= print_symbol (- left, "false");
19131 break;
19132 }
19133
19134 if (do_wide && left > 0)
19135 printf ("%-*s", left, " ");
19136
19137 return TRUE;
19138 }
19139
19140 /* Note that by the ELF standard, the name field is already null byte
19141 terminated, and namesz includes the terminating null byte.
19142 I.E. the value of namesz for the name "FSF" is 4.
19143
19144 If the value of namesz is zero, there is no name present. */
19145
19146 static bfd_boolean
19147 process_note (Elf_Internal_Note * pnote,
19148 Filedata * filedata)
19149 {
19150 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
19151 const char * nt;
19152
19153 if (pnote->namesz == 0)
19154 /* If there is no note name, then use the default set of
19155 note type strings. */
19156 nt = get_note_type (filedata, pnote->type);
19157
19158 else if (const_strneq (pnote->namedata, "GNU"))
19159 /* GNU-specific object file notes. */
19160 nt = get_gnu_elf_note_type (pnote->type);
19161
19162 else if (const_strneq (pnote->namedata, "AMD")
19163 || const_strneq (pnote->namedata, "AMDGPU"))
19164 /* AMD-specific object file notes. */
19165 nt = get_amd_elf_note_type (pnote->type);
19166
19167 else if (const_strneq (pnote->namedata, "FreeBSD"))
19168 /* FreeBSD-specific core file notes. */
19169 nt = get_freebsd_elfcore_note_type (filedata, pnote->type);
19170
19171 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
19172 /* NetBSD-specific core file notes. */
19173 nt = get_netbsd_elfcore_note_type (filedata, pnote->type);
19174
19175 else if (const_strneq (pnote->namedata, "NetBSD"))
19176 /* NetBSD-specific core file notes. */
19177 return process_netbsd_elf_note (pnote);
19178
19179 else if (const_strneq (pnote->namedata, "PaX"))
19180 /* NetBSD-specific core file notes. */
19181 return process_netbsd_elf_note (pnote);
19182
19183 else if (strneq (pnote->namedata, "SPU/", 4))
19184 {
19185 /* SPU-specific core file notes. */
19186 nt = pnote->namedata + 4;
19187 name = "SPU";
19188 }
19189
19190 else if (const_strneq (pnote->namedata, "IPF/VMS"))
19191 /* VMS/ia64-specific file notes. */
19192 nt = get_ia64_vms_note_type (pnote->type);
19193
19194 else if (const_strneq (pnote->namedata, "stapsdt"))
19195 nt = get_stapsdt_note_type (pnote->type);
19196
19197 else
19198 /* Don't recognize this note name; just use the default set of
19199 note type strings. */
19200 nt = get_note_type (filedata, pnote->type);
19201
19202 printf (" ");
19203
19204 if (((const_strneq (pnote->namedata, "GA")
19205 && strchr ("*$!+", pnote->namedata[2]) != NULL)
19206 || strchr ("*$!+", pnote->namedata[0]) != NULL)
19207 && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
19208 || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
19209 print_gnu_build_attribute_name (pnote);
19210 else
19211 print_symbol (-20, name);
19212
19213 if (do_wide)
19214 printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
19215 else
19216 printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
19217
19218 if (const_strneq (pnote->namedata, "IPF/VMS"))
19219 return print_ia64_vms_note (pnote);
19220 else if (const_strneq (pnote->namedata, "GNU"))
19221 return print_gnu_note (filedata, pnote);
19222 else if (const_strneq (pnote->namedata, "AMD")
19223 || const_strneq (pnote->namedata, "AMDGPU"))
19224 return print_amd_note (pnote);
19225 else if (const_strneq (pnote->namedata, "stapsdt"))
19226 return print_stapsdt_note (pnote);
19227 else if (const_strneq (pnote->namedata, "CORE"))
19228 return print_core_note (pnote);
19229 else if (((const_strneq (pnote->namedata, "GA")
19230 && strchr ("*$!+", pnote->namedata[2]) != NULL)
19231 || strchr ("*$!+", pnote->namedata[0]) != NULL)
19232 && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
19233 || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
19234 return print_gnu_build_attribute_description (pnote, filedata);
19235
19236 if (pnote->descsz)
19237 {
19238 unsigned long i;
19239
19240 printf (_(" description data: "));
19241 for (i = 0; i < pnote->descsz; i++)
19242 printf ("%02x ", pnote->descdata[i] & 0xff);
19243 if (!do_wide)
19244 printf ("\n");
19245 }
19246
19247 if (do_wide)
19248 printf ("\n");
19249
19250 return TRUE;
19251 }
19252
19253 static bfd_boolean
19254 process_notes_at (Filedata * filedata,
19255 Elf_Internal_Shdr * section,
19256 bfd_vma offset,
19257 bfd_vma length,
19258 bfd_vma align)
19259 {
19260 Elf_External_Note * pnotes;
19261 Elf_External_Note * external;
19262 char * end;
19263 bfd_boolean res = TRUE;
19264
19265 if (length <= 0)
19266 return FALSE;
19267
19268 if (section)
19269 {
19270 pnotes = (Elf_External_Note *) get_section_contents (section, filedata);
19271 if (pnotes)
19272 {
19273 if (! apply_relocations (filedata, section, (unsigned char *) pnotes, length, NULL, NULL))
19274 return FALSE;
19275 }
19276 }
19277 else
19278 pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
19279 _("notes"));
19280
19281 if (pnotes == NULL)
19282 return FALSE;
19283
19284 external = pnotes;
19285
19286 if (section)
19287 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata, section));
19288 else
19289 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19290 (unsigned long) offset, (unsigned long) length);
19291
19292 /* NB: Some note sections may have alignment value of 0 or 1. gABI
19293 specifies that notes should be aligned to 4 bytes in 32-bit
19294 objects and to 8 bytes in 64-bit objects. As a Linux extension,
19295 we also support 4 byte alignment in 64-bit objects. If section
19296 alignment is less than 4, we treate alignment as 4 bytes. */
19297 if (align < 4)
19298 align = 4;
19299 else if (align != 4 && align != 8)
19300 {
19301 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19302 (long) align);
19303 return FALSE;
19304 }
19305
19306 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
19307
19308 end = (char *) pnotes + length;
19309 while ((char *) external < end)
19310 {
19311 Elf_Internal_Note inote;
19312 size_t min_notesz;
19313 char * next;
19314 char * temp = NULL;
19315 size_t data_remaining = end - (char *) external;
19316
19317 if (!is_ia64_vms (filedata))
19318 {
19319 /* PR binutils/15191
19320 Make sure that there is enough data to read. */
19321 min_notesz = offsetof (Elf_External_Note, name);
19322 if (data_remaining < min_notesz)
19323 {
19324 warn (ngettext ("Corrupt note: only %ld byte remains, "
19325 "not enough for a full note\n",
19326 "Corrupt note: only %ld bytes remain, "
19327 "not enough for a full note\n",
19328 data_remaining),
19329 (long) data_remaining);
19330 break;
19331 }
19332 data_remaining -= min_notesz;
19333
19334 inote.type = BYTE_GET (external->type);
19335 inote.namesz = BYTE_GET (external->namesz);
19336 inote.namedata = external->name;
19337 inote.descsz = BYTE_GET (external->descsz);
19338 inote.descdata = ((char *) external
19339 + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
19340 inote.descpos = offset + (inote.descdata - (char *) pnotes);
19341 next = ((char *) external
19342 + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
19343 }
19344 else
19345 {
19346 Elf64_External_VMS_Note *vms_external;
19347
19348 /* PR binutils/15191
19349 Make sure that there is enough data to read. */
19350 min_notesz = offsetof (Elf64_External_VMS_Note, name);
19351 if (data_remaining < min_notesz)
19352 {
19353 warn (ngettext ("Corrupt note: only %ld byte remains, "
19354 "not enough for a full note\n",
19355 "Corrupt note: only %ld bytes remain, "
19356 "not enough for a full note\n",
19357 data_remaining),
19358 (long) data_remaining);
19359 break;
19360 }
19361 data_remaining -= min_notesz;
19362
19363 vms_external = (Elf64_External_VMS_Note *) external;
19364 inote.type = BYTE_GET (vms_external->type);
19365 inote.namesz = BYTE_GET (vms_external->namesz);
19366 inote.namedata = vms_external->name;
19367 inote.descsz = BYTE_GET (vms_external->descsz);
19368 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
19369 inote.descpos = offset + (inote.descdata - (char *) pnotes);
19370 next = inote.descdata + align_power (inote.descsz, 3);
19371 }
19372
19373 /* PR 17531: file: 3443835e. */
19374 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
19375 if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
19376 || (size_t) (inote.descdata - inote.namedata) > data_remaining
19377 || (size_t) (next - inote.descdata) < inote.descsz
19378 || ((size_t) (next - inote.descdata)
19379 > data_remaining - (size_t) (inote.descdata - inote.namedata)))
19380 {
19381 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
19382 (unsigned long) ((char *) external - (char *) pnotes));
19383 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
19384 inote.type, inote.namesz, inote.descsz, (int) align);
19385 break;
19386 }
19387
19388 external = (Elf_External_Note *) next;
19389
19390 /* Verify that name is null terminated. It appears that at least
19391 one version of Linux (RedHat 6.0) generates corefiles that don't
19392 comply with the ELF spec by failing to include the null byte in
19393 namesz. */
19394 if (inote.namesz > 0 && inote.namedata[inote.namesz - 1] != '\0')
19395 {
19396 if ((size_t) (inote.descdata - inote.namedata) == inote.namesz)
19397 {
19398 temp = (char *) malloc (inote.namesz + 1);
19399 if (temp == NULL)
19400 {
19401 error (_("Out of memory allocating space for inote name\n"));
19402 res = FALSE;
19403 break;
19404 }
19405
19406 memcpy (temp, inote.namedata, inote.namesz);
19407 inote.namedata = temp;
19408 }
19409 inote.namedata[inote.namesz] = 0;
19410 }
19411
19412 if (! process_note (& inote, filedata))
19413 res = FALSE;
19414
19415 if (temp != NULL)
19416 {
19417 free (temp);
19418 temp = NULL;
19419 }
19420 }
19421
19422 free (pnotes);
19423
19424 return res;
19425 }
19426
19427 static bfd_boolean
19428 process_corefile_note_segments (Filedata * filedata)
19429 {
19430 Elf_Internal_Phdr * segment;
19431 unsigned int i;
19432 bfd_boolean res = TRUE;
19433
19434 if (! get_program_headers (filedata))
19435 return TRUE;
19436
19437 for (i = 0, segment = filedata->program_headers;
19438 i < filedata->file_header.e_phnum;
19439 i++, segment++)
19440 {
19441 if (segment->p_type == PT_NOTE)
19442 if (! process_notes_at (filedata, NULL,
19443 (bfd_vma) segment->p_offset,
19444 (bfd_vma) segment->p_filesz,
19445 (bfd_vma) segment->p_align))
19446 res = FALSE;
19447 }
19448
19449 return res;
19450 }
19451
19452 static bfd_boolean
19453 process_v850_notes (Filedata * filedata, bfd_vma offset, bfd_vma length)
19454 {
19455 Elf_External_Note * pnotes;
19456 Elf_External_Note * external;
19457 char * end;
19458 bfd_boolean res = TRUE;
19459
19460 if (length <= 0)
19461 return FALSE;
19462
19463 pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
19464 _("v850 notes"));
19465 if (pnotes == NULL)
19466 return FALSE;
19467
19468 external = pnotes;
19469 end = (char*) pnotes + length;
19470
19471 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
19472 (unsigned long) offset, (unsigned long) length);
19473
19474 while ((char *) external + sizeof (Elf_External_Note) < end)
19475 {
19476 Elf_External_Note * next;
19477 Elf_Internal_Note inote;
19478
19479 inote.type = BYTE_GET (external->type);
19480 inote.namesz = BYTE_GET (external->namesz);
19481 inote.namedata = external->name;
19482 inote.descsz = BYTE_GET (external->descsz);
19483 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
19484 inote.descpos = offset + (inote.descdata - (char *) pnotes);
19485
19486 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
19487 {
19488 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
19489 inote.descdata = inote.namedata;
19490 inote.namesz = 0;
19491 }
19492
19493 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
19494
19495 if ( ((char *) next > end)
19496 || ((char *) next < (char *) pnotes))
19497 {
19498 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19499 (unsigned long) ((char *) external - (char *) pnotes));
19500 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19501 inote.type, inote.namesz, inote.descsz);
19502 break;
19503 }
19504
19505 external = next;
19506
19507 /* Prevent out-of-bounds indexing. */
19508 if ( inote.namedata + inote.namesz > end
19509 || inote.namedata + inote.namesz < inote.namedata)
19510 {
19511 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19512 (unsigned long) ((char *) external - (char *) pnotes));
19513 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19514 inote.type, inote.namesz, inote.descsz);
19515 break;
19516 }
19517
19518 printf (" %s: ", get_v850_elf_note_type (inote.type));
19519
19520 if (! print_v850_note (& inote))
19521 {
19522 res = FALSE;
19523 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19524 inote.namesz, inote.descsz);
19525 }
19526 }
19527
19528 free (pnotes);
19529
19530 return res;
19531 }
19532
19533 static bfd_boolean
19534 process_note_sections (Filedata * filedata)
19535 {
19536 Elf_Internal_Shdr * section;
19537 unsigned long i;
19538 unsigned int n = 0;
19539 bfd_boolean res = TRUE;
19540
19541 for (i = 0, section = filedata->section_headers;
19542 i < filedata->file_header.e_shnum && section != NULL;
19543 i++, section++)
19544 {
19545 if (section->sh_type == SHT_NOTE)
19546 {
19547 if (! process_notes_at (filedata, section,
19548 (bfd_vma) section->sh_offset,
19549 (bfd_vma) section->sh_size,
19550 (bfd_vma) section->sh_addralign))
19551 res = FALSE;
19552 n++;
19553 }
19554
19555 if (( filedata->file_header.e_machine == EM_V800
19556 || filedata->file_header.e_machine == EM_V850
19557 || filedata->file_header.e_machine == EM_CYGNUS_V850)
19558 && section->sh_type == SHT_RENESAS_INFO)
19559 {
19560 if (! process_v850_notes (filedata,
19561 (bfd_vma) section->sh_offset,
19562 (bfd_vma) section->sh_size))
19563 res = FALSE;
19564 n++;
19565 }
19566 }
19567
19568 if (n == 0)
19569 /* Try processing NOTE segments instead. */
19570 return process_corefile_note_segments (filedata);
19571
19572 return res;
19573 }
19574
19575 static bfd_boolean
19576 process_notes (Filedata * filedata)
19577 {
19578 /* If we have not been asked to display the notes then do nothing. */
19579 if (! do_notes)
19580 return TRUE;
19581
19582 if (filedata->file_header.e_type != ET_CORE)
19583 return process_note_sections (filedata);
19584
19585 /* No program headers means no NOTE segment. */
19586 if (filedata->file_header.e_phnum > 0)
19587 return process_corefile_note_segments (filedata);
19588
19589 printf (_("No note segments present in the core file.\n"));
19590 return TRUE;
19591 }
19592
19593 static unsigned char *
19594 display_public_gnu_attributes (unsigned char * start,
19595 const unsigned char * const end)
19596 {
19597 printf (_(" Unknown GNU attribute: %s\n"), start);
19598
19599 start += strnlen ((char *) start, end - start);
19600 display_raw_attribute (start, end);
19601
19602 return (unsigned char *) end;
19603 }
19604
19605 static unsigned char *
19606 display_generic_attribute (unsigned char * start,
19607 unsigned int tag,
19608 const unsigned char * const end)
19609 {
19610 if (tag == 0)
19611 return (unsigned char *) end;
19612
19613 return display_tag_value (tag, start, end);
19614 }
19615
19616 static bfd_boolean
19617 process_arch_specific (Filedata * filedata)
19618 {
19619 if (! do_arch)
19620 return TRUE;
19621
19622 switch (filedata->file_header.e_machine)
19623 {
19624 case EM_ARC:
19625 case EM_ARC_COMPACT:
19626 case EM_ARC_COMPACT2:
19627 return process_attributes (filedata, "ARC", SHT_ARC_ATTRIBUTES,
19628 display_arc_attribute,
19629 display_generic_attribute);
19630 case EM_ARM:
19631 return process_attributes (filedata, "aeabi", SHT_ARM_ATTRIBUTES,
19632 display_arm_attribute,
19633 display_generic_attribute);
19634
19635 case EM_MIPS:
19636 case EM_MIPS_RS3_LE:
19637 return process_mips_specific (filedata);
19638
19639 case EM_MSP430:
19640 return process_attributes (filedata, "mspabi", SHT_MSP430_ATTRIBUTES,
19641 display_msp430x_attribute,
19642 display_msp430_gnu_attribute);
19643
19644 case EM_RISCV:
19645 return process_attributes (filedata, "riscv", SHT_RISCV_ATTRIBUTES,
19646 display_riscv_attribute,
19647 display_generic_attribute);
19648
19649 case EM_NDS32:
19650 return process_nds32_specific (filedata);
19651
19652 case EM_PPC:
19653 case EM_PPC64:
19654 return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
19655 display_power_gnu_attribute);
19656
19657 case EM_S390:
19658 case EM_S390_OLD:
19659 return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
19660 display_s390_gnu_attribute);
19661
19662 case EM_SPARC:
19663 case EM_SPARC32PLUS:
19664 case EM_SPARCV9:
19665 return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
19666 display_sparc_gnu_attribute);
19667
19668 case EM_TI_C6000:
19669 return process_attributes (filedata, "c6xabi", SHT_C6000_ATTRIBUTES,
19670 display_tic6x_attribute,
19671 display_generic_attribute);
19672
19673 default:
19674 return process_attributes (filedata, "gnu", SHT_GNU_ATTRIBUTES,
19675 display_public_gnu_attributes,
19676 display_generic_attribute);
19677 }
19678 }
19679
19680 static bfd_boolean
19681 get_file_header (Filedata * filedata)
19682 {
19683 /* Read in the identity array. */
19684 if (fread (filedata->file_header.e_ident, EI_NIDENT, 1, filedata->handle) != 1)
19685 return FALSE;
19686
19687 /* Determine how to read the rest of the header. */
19688 switch (filedata->file_header.e_ident[EI_DATA])
19689 {
19690 default:
19691 case ELFDATANONE:
19692 case ELFDATA2LSB:
19693 byte_get = byte_get_little_endian;
19694 byte_put = byte_put_little_endian;
19695 break;
19696 case ELFDATA2MSB:
19697 byte_get = byte_get_big_endian;
19698 byte_put = byte_put_big_endian;
19699 break;
19700 }
19701
19702 /* For now we only support 32 bit and 64 bit ELF files. */
19703 is_32bit_elf = (filedata->file_header.e_ident[EI_CLASS] != ELFCLASS64);
19704
19705 /* Read in the rest of the header. */
19706 if (is_32bit_elf)
19707 {
19708 Elf32_External_Ehdr ehdr32;
19709
19710 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, filedata->handle) != 1)
19711 return FALSE;
19712
19713 filedata->file_header.e_type = BYTE_GET (ehdr32.e_type);
19714 filedata->file_header.e_machine = BYTE_GET (ehdr32.e_machine);
19715 filedata->file_header.e_version = BYTE_GET (ehdr32.e_version);
19716 filedata->file_header.e_entry = BYTE_GET (ehdr32.e_entry);
19717 filedata->file_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
19718 filedata->file_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
19719 filedata->file_header.e_flags = BYTE_GET (ehdr32.e_flags);
19720 filedata->file_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
19721 filedata->file_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
19722 filedata->file_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
19723 filedata->file_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
19724 filedata->file_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
19725 filedata->file_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
19726 }
19727 else
19728 {
19729 Elf64_External_Ehdr ehdr64;
19730
19731 /* If we have been compiled with sizeof (bfd_vma) == 4, then
19732 we will not be able to cope with the 64bit data found in
19733 64 ELF files. Detect this now and abort before we start
19734 overwriting things. */
19735 if (sizeof (bfd_vma) < 8)
19736 {
19737 error (_("This instance of readelf has been built without support for a\n\
19738 64 bit data type and so it cannot read 64 bit ELF files.\n"));
19739 return FALSE;
19740 }
19741
19742 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, filedata->handle) != 1)
19743 return FALSE;
19744
19745 filedata->file_header.e_type = BYTE_GET (ehdr64.e_type);
19746 filedata->file_header.e_machine = BYTE_GET (ehdr64.e_machine);
19747 filedata->file_header.e_version = BYTE_GET (ehdr64.e_version);
19748 filedata->file_header.e_entry = BYTE_GET (ehdr64.e_entry);
19749 filedata->file_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
19750 filedata->file_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
19751 filedata->file_header.e_flags = BYTE_GET (ehdr64.e_flags);
19752 filedata->file_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
19753 filedata->file_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
19754 filedata->file_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
19755 filedata->file_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
19756 filedata->file_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
19757 filedata->file_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
19758 }
19759
19760 if (filedata->file_header.e_shoff)
19761 {
19762 /* There may be some extensions in the first section header. Don't
19763 bomb if we can't read it. */
19764 if (is_32bit_elf)
19765 get_32bit_section_headers (filedata, TRUE);
19766 else
19767 get_64bit_section_headers (filedata, TRUE);
19768 }
19769
19770 return TRUE;
19771 }
19772
19773 static void
19774 close_file (Filedata * filedata)
19775 {
19776 if (filedata)
19777 {
19778 if (filedata->handle)
19779 fclose (filedata->handle);
19780 free (filedata);
19781 }
19782 }
19783
19784 void
19785 close_debug_file (void * data)
19786 {
19787 close_file ((Filedata *) data);
19788 }
19789
19790 static Filedata *
19791 open_file (const char * pathname)
19792 {
19793 struct stat statbuf;
19794 Filedata * filedata = NULL;
19795
19796 if (stat (pathname, & statbuf) < 0
19797 || ! S_ISREG (statbuf.st_mode))
19798 goto fail;
19799
19800 filedata = calloc (1, sizeof * filedata);
19801 if (filedata == NULL)
19802 goto fail;
19803
19804 filedata->handle = fopen (pathname, "rb");
19805 if (filedata->handle == NULL)
19806 goto fail;
19807
19808 filedata->file_size = (bfd_size_type) statbuf.st_size;
19809 filedata->file_name = pathname;
19810
19811 if (! get_file_header (filedata))
19812 goto fail;
19813
19814 if (filedata->file_header.e_shoff)
19815 {
19816 bfd_boolean res;
19817
19818 /* Read the section headers again, this time for real. */
19819 if (is_32bit_elf)
19820 res = get_32bit_section_headers (filedata, FALSE);
19821 else
19822 res = get_64bit_section_headers (filedata, FALSE);
19823
19824 if (!res)
19825 goto fail;
19826 }
19827
19828 return filedata;
19829
19830 fail:
19831 if (filedata)
19832 {
19833 if (filedata->handle)
19834 fclose (filedata->handle);
19835 free (filedata);
19836 }
19837 return NULL;
19838 }
19839
19840 void *
19841 open_debug_file (const char * pathname)
19842 {
19843 return open_file (pathname);
19844 }
19845
19846 /* Process one ELF object file according to the command line options.
19847 This file may actually be stored in an archive. The file is
19848 positioned at the start of the ELF object. Returns TRUE if no
19849 problems were encountered, FALSE otherwise. */
19850
19851 static bfd_boolean
19852 process_object (Filedata * filedata)
19853 {
19854 bfd_boolean have_separate_files;
19855 unsigned int i;
19856 bfd_boolean res = TRUE;
19857
19858 if (! get_file_header (filedata))
19859 {
19860 error (_("%s: Failed to read file header\n"), filedata->file_name);
19861 return FALSE;
19862 }
19863
19864 /* Initialise per file variables. */
19865 for (i = ARRAY_SIZE (version_info); i--;)
19866 version_info[i] = 0;
19867
19868 for (i = ARRAY_SIZE (dynamic_info); i--;)
19869 dynamic_info[i] = 0;
19870 dynamic_info_DT_GNU_HASH = 0;
19871 dynamic_info_DT_MIPS_XHASH = 0;
19872
19873 /* Process the file. */
19874 if (show_name)
19875 printf (_("\nFile: %s\n"), filedata->file_name);
19876
19877 /* Initialise the dump_sects array from the cmdline_dump_sects array.
19878 Note we do this even if cmdline_dump_sects is empty because we
19879 must make sure that the dump_sets array is zeroed out before each
19880 object file is processed. */
19881 if (filedata->num_dump_sects > cmdline.num_dump_sects)
19882 memset (filedata->dump_sects, 0, filedata->num_dump_sects * sizeof (* filedata->dump_sects));
19883
19884 if (cmdline.num_dump_sects > 0)
19885 {
19886 if (filedata->num_dump_sects == 0)
19887 /* A sneaky way of allocating the dump_sects array. */
19888 request_dump_bynumber (filedata, cmdline.num_dump_sects, 0);
19889
19890 assert (filedata->num_dump_sects >= cmdline.num_dump_sects);
19891 memcpy (filedata->dump_sects, cmdline.dump_sects,
19892 cmdline.num_dump_sects * sizeof (* filedata->dump_sects));
19893 }
19894
19895 if (! process_file_header (filedata))
19896 return FALSE;
19897
19898 if (! process_section_headers (filedata))
19899 {
19900 /* Without loaded section headers we cannot process lots of things. */
19901 do_unwind = do_version = do_dump = do_arch = FALSE;
19902
19903 if (! do_using_dynamic)
19904 do_syms = do_dyn_syms = do_reloc = FALSE;
19905 }
19906
19907 if (! process_section_groups (filedata))
19908 /* Without loaded section groups we cannot process unwind. */
19909 do_unwind = FALSE;
19910
19911 if (process_program_headers (filedata))
19912 process_dynamic_section (filedata);
19913 else
19914 res = FALSE;
19915
19916 if (! process_relocs (filedata))
19917 res = FALSE;
19918
19919 if (! process_unwind (filedata))
19920 res = FALSE;
19921
19922 if (! process_symbol_table (filedata))
19923 res = FALSE;
19924
19925 if (! process_syminfo (filedata))
19926 res = FALSE;
19927
19928 if (! process_version_sections (filedata))
19929 res = FALSE;
19930
19931 if (filedata->file_header.e_shstrndx != SHN_UNDEF)
19932 have_separate_files = load_separate_debug_files (filedata, filedata->file_name);
19933 else
19934 have_separate_files = FALSE;
19935
19936 if (! process_section_contents (filedata))
19937 res = FALSE;
19938
19939 if (have_separate_files)
19940 {
19941 separate_info * d;
19942
19943 for (d = first_separate_info; d != NULL; d = d->next)
19944 {
19945 if (! process_section_headers (d->handle))
19946 res = FALSE;
19947 else if (! process_section_contents (d->handle))
19948 res = FALSE;
19949 }
19950
19951 /* The file handles are closed by the call to free_debug_memory() below. */
19952 }
19953
19954 if (! process_notes (filedata))
19955 res = FALSE;
19956
19957 if (! process_gnu_liblist (filedata))
19958 res = FALSE;
19959
19960 if (! process_arch_specific (filedata))
19961 res = FALSE;
19962
19963 free (filedata->program_headers);
19964 filedata->program_headers = NULL;
19965
19966 free (filedata->section_headers);
19967 filedata->section_headers = NULL;
19968
19969 free (filedata->string_table);
19970 filedata->string_table = NULL;
19971 filedata->string_table_length = 0;
19972
19973 if (dynamic_strings)
19974 {
19975 free (dynamic_strings);
19976 dynamic_strings = NULL;
19977 dynamic_strings_length = 0;
19978 }
19979
19980 if (dynamic_symbols)
19981 {
19982 free (dynamic_symbols);
19983 dynamic_symbols = NULL;
19984 num_dynamic_syms = 0;
19985 }
19986
19987 if (dynamic_syminfo)
19988 {
19989 free (dynamic_syminfo);
19990 dynamic_syminfo = NULL;
19991 }
19992
19993 if (dynamic_section)
19994 {
19995 free (dynamic_section);
19996 dynamic_section = NULL;
19997 }
19998
19999 if (section_headers_groups)
20000 {
20001 free (section_headers_groups);
20002 section_headers_groups = NULL;
20003 }
20004
20005 if (section_groups)
20006 {
20007 struct group_list * g;
20008 struct group_list * next;
20009
20010 for (i = 0; i < group_count; i++)
20011 {
20012 for (g = section_groups [i].root; g != NULL; g = next)
20013 {
20014 next = g->next;
20015 free (g);
20016 }
20017 }
20018
20019 free (section_groups);
20020 section_groups = NULL;
20021 }
20022
20023 free_debug_memory ();
20024
20025 return res;
20026 }
20027
20028 /* Process an ELF archive.
20029 On entry the file is positioned just after the ARMAG string.
20030 Returns TRUE upon success, FALSE otherwise. */
20031
20032 static bfd_boolean
20033 process_archive (Filedata * filedata, bfd_boolean is_thin_archive)
20034 {
20035 struct archive_info arch;
20036 struct archive_info nested_arch;
20037 size_t got;
20038 bfd_boolean ret = TRUE;
20039
20040 show_name = TRUE;
20041
20042 /* The ARCH structure is used to hold information about this archive. */
20043 arch.file_name = NULL;
20044 arch.file = NULL;
20045 arch.index_array = NULL;
20046 arch.sym_table = NULL;
20047 arch.longnames = NULL;
20048
20049 /* The NESTED_ARCH structure is used as a single-item cache of information
20050 about a nested archive (when members of a thin archive reside within
20051 another regular archive file). */
20052 nested_arch.file_name = NULL;
20053 nested_arch.file = NULL;
20054 nested_arch.index_array = NULL;
20055 nested_arch.sym_table = NULL;
20056 nested_arch.longnames = NULL;
20057
20058 if (setup_archive (&arch, filedata->file_name, filedata->handle,
20059 is_thin_archive, do_archive_index) != 0)
20060 {
20061 ret = FALSE;
20062 goto out;
20063 }
20064
20065 if (do_archive_index)
20066 {
20067 if (arch.sym_table == NULL)
20068 error (_("%s: unable to dump the index as none was found\n"), filedata->file_name);
20069 else
20070 {
20071 unsigned long i, l;
20072 unsigned long current_pos;
20073
20074 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
20075 filedata->file_name, (unsigned long) arch.index_num, arch.sym_size);
20076
20077 current_pos = ftell (filedata->handle);
20078
20079 for (i = l = 0; i < arch.index_num; i++)
20080 {
20081 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
20082 {
20083 char * member_name;
20084
20085 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
20086
20087 if (member_name != NULL)
20088 {
20089 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
20090
20091 if (qualified_name != NULL)
20092 {
20093 printf (_("Contents of binary %s at offset "), qualified_name);
20094 (void) print_vma (arch.index_array[i], PREFIX_HEX);
20095 putchar ('\n');
20096 free (qualified_name);
20097 }
20098 }
20099 }
20100
20101 if (l >= arch.sym_size)
20102 {
20103 error (_("%s: end of the symbol table reached before the end of the index\n"),
20104 filedata->file_name);
20105 ret = FALSE;
20106 break;
20107 }
20108 /* PR 17531: file: 0b6630b2. */
20109 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
20110 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
20111 }
20112
20113 if (arch.uses_64bit_indices)
20114 l = (l + 7) & ~ 7;
20115 else
20116 l += l & 1;
20117
20118 if (l < arch.sym_size)
20119 {
20120 error (ngettext ("%s: %ld byte remains in the symbol table, "
20121 "but without corresponding entries in "
20122 "the index table\n",
20123 "%s: %ld bytes remain in the symbol table, "
20124 "but without corresponding entries in "
20125 "the index table\n",
20126 arch.sym_size - l),
20127 filedata->file_name, arch.sym_size - l);
20128 ret = FALSE;
20129 }
20130
20131 if (fseek (filedata->handle, current_pos, SEEK_SET) != 0)
20132 {
20133 error (_("%s: failed to seek back to start of object files in the archive\n"),
20134 filedata->file_name);
20135 ret = FALSE;
20136 goto out;
20137 }
20138 }
20139
20140 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
20141 && !do_segments && !do_header && !do_dump && !do_version
20142 && !do_histogram && !do_debugging && !do_arch && !do_notes
20143 && !do_section_groups && !do_dyn_syms)
20144 {
20145 ret = TRUE; /* Archive index only. */
20146 goto out;
20147 }
20148 }
20149
20150 while (1)
20151 {
20152 char * name;
20153 size_t namelen;
20154 char * qualified_name;
20155
20156 /* Read the next archive header. */
20157 if (fseek (filedata->handle, arch.next_arhdr_offset, SEEK_SET) != 0)
20158 {
20159 error (_("%s: failed to seek to next archive header\n"), arch.file_name);
20160 return FALSE;
20161 }
20162 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, filedata->handle);
20163 if (got != sizeof arch.arhdr)
20164 {
20165 if (got == 0)
20166 break;
20167 /* PR 24049 - we cannot use filedata->file_name as this will
20168 have already been freed. */
20169 error (_("%s: failed to read archive header\n"), arch.file_name);
20170
20171 ret = FALSE;
20172 break;
20173 }
20174 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
20175 {
20176 error (_("%s: did not find a valid archive header\n"), arch.file_name);
20177 ret = FALSE;
20178 break;
20179 }
20180
20181 arch.next_arhdr_offset += sizeof arch.arhdr;
20182
20183 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
20184 if (archive_file_size & 01)
20185 ++archive_file_size;
20186
20187 name = get_archive_member_name (&arch, &nested_arch);
20188 if (name == NULL)
20189 {
20190 error (_("%s: bad archive file name\n"), arch.file_name);
20191 ret = FALSE;
20192 break;
20193 }
20194 namelen = strlen (name);
20195
20196 qualified_name = make_qualified_name (&arch, &nested_arch, name);
20197 if (qualified_name == NULL)
20198 {
20199 error (_("%s: bad archive file name\n"), arch.file_name);
20200 ret = FALSE;
20201 break;
20202 }
20203
20204 if (is_thin_archive && arch.nested_member_origin == 0)
20205 {
20206 /* This is a proxy for an external member of a thin archive. */
20207 Filedata * member_filedata;
20208 char * member_file_name = adjust_relative_path
20209 (filedata->file_name, name, namelen);
20210
20211 if (member_file_name == NULL)
20212 {
20213 ret = FALSE;
20214 break;
20215 }
20216
20217 member_filedata = open_file (member_file_name);
20218 if (member_filedata == NULL)
20219 {
20220 error (_("Input file '%s' is not readable.\n"), member_file_name);
20221 free (member_file_name);
20222 ret = FALSE;
20223 break;
20224 }
20225
20226 archive_file_offset = arch.nested_member_origin;
20227 member_filedata->file_name = qualified_name;
20228
20229 if (! process_object (member_filedata))
20230 ret = FALSE;
20231
20232 close_file (member_filedata);
20233 free (member_file_name);
20234 }
20235 else if (is_thin_archive)
20236 {
20237 Filedata thin_filedata;
20238
20239 memset (&thin_filedata, 0, sizeof (thin_filedata));
20240
20241 /* PR 15140: Allow for corrupt thin archives. */
20242 if (nested_arch.file == NULL)
20243 {
20244 error (_("%s: contains corrupt thin archive: %s\n"),
20245 qualified_name, name);
20246 ret = FALSE;
20247 break;
20248 }
20249
20250 /* This is a proxy for a member of a nested archive. */
20251 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
20252
20253 /* The nested archive file will have been opened and setup by
20254 get_archive_member_name. */
20255 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
20256 {
20257 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
20258 ret = FALSE;
20259 break;
20260 }
20261
20262 thin_filedata.handle = nested_arch.file;
20263 thin_filedata.file_name = qualified_name;
20264
20265 if (! process_object (& thin_filedata))
20266 ret = FALSE;
20267 }
20268 else
20269 {
20270 archive_file_offset = arch.next_arhdr_offset;
20271 arch.next_arhdr_offset += archive_file_size;
20272
20273 filedata->file_name = qualified_name;
20274 if (! process_object (filedata))
20275 ret = FALSE;
20276 }
20277
20278 if (filedata->dump_sects != NULL)
20279 {
20280 free (filedata->dump_sects);
20281 filedata->dump_sects = NULL;
20282 filedata->num_dump_sects = 0;
20283 }
20284
20285 free (qualified_name);
20286 }
20287
20288 out:
20289 if (nested_arch.file != NULL)
20290 fclose (nested_arch.file);
20291 release_archive (&nested_arch);
20292 release_archive (&arch);
20293
20294 return ret;
20295 }
20296
20297 static bfd_boolean
20298 process_file (char * file_name)
20299 {
20300 Filedata * filedata = NULL;
20301 struct stat statbuf;
20302 char armag[SARMAG];
20303 bfd_boolean ret = TRUE;
20304
20305 if (stat (file_name, &statbuf) < 0)
20306 {
20307 if (errno == ENOENT)
20308 error (_("'%s': No such file\n"), file_name);
20309 else
20310 error (_("Could not locate '%s'. System error message: %s\n"),
20311 file_name, strerror (errno));
20312 return FALSE;
20313 }
20314
20315 if (! S_ISREG (statbuf.st_mode))
20316 {
20317 error (_("'%s' is not an ordinary file\n"), file_name);
20318 return FALSE;
20319 }
20320
20321 filedata = calloc (1, sizeof * filedata);
20322 if (filedata == NULL)
20323 {
20324 error (_("Out of memory allocating file data structure\n"));
20325 return FALSE;
20326 }
20327
20328 filedata->file_name = file_name;
20329 filedata->handle = fopen (file_name, "rb");
20330 if (filedata->handle == NULL)
20331 {
20332 error (_("Input file '%s' is not readable.\n"), file_name);
20333 free (filedata);
20334 return FALSE;
20335 }
20336
20337 if (fread (armag, SARMAG, 1, filedata->handle) != 1)
20338 {
20339 error (_("%s: Failed to read file's magic number\n"), file_name);
20340 fclose (filedata->handle);
20341 free (filedata);
20342 return FALSE;
20343 }
20344
20345 filedata->file_size = (bfd_size_type) statbuf.st_size;
20346
20347 if (memcmp (armag, ARMAG, SARMAG) == 0)
20348 {
20349 if (! process_archive (filedata, FALSE))
20350 ret = FALSE;
20351 }
20352 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
20353 {
20354 if ( ! process_archive (filedata, TRUE))
20355 ret = FALSE;
20356 }
20357 else
20358 {
20359 if (do_archive_index)
20360 error (_("File %s is not an archive so its index cannot be displayed.\n"),
20361 file_name);
20362
20363 rewind (filedata->handle);
20364 archive_file_size = archive_file_offset = 0;
20365
20366 if (! process_object (filedata))
20367 ret = FALSE;
20368 }
20369
20370 fclose (filedata->handle);
20371 free (filedata);
20372
20373 return ret;
20374 }
20375
20376 #ifdef SUPPORT_DISASSEMBLY
20377 /* Needed by the i386 disassembler. For extra credit, someone could
20378 fix this so that we insert symbolic addresses here, esp for GOT/PLT
20379 symbols. */
20380
20381 void
20382 print_address (unsigned int addr, FILE * outfile)
20383 {
20384 fprintf (outfile,"0x%8.8x", addr);
20385 }
20386
20387 /* Needed by the i386 disassembler. */
20388
20389 void
20390 db_task_printsym (unsigned int addr)
20391 {
20392 print_address (addr, stderr);
20393 }
20394 #endif
20395
20396 int
20397 main (int argc, char ** argv)
20398 {
20399 int err;
20400
20401 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
20402 setlocale (LC_MESSAGES, "");
20403 #endif
20404 #if defined (HAVE_SETLOCALE)
20405 setlocale (LC_CTYPE, "");
20406 #endif
20407 bindtextdomain (PACKAGE, LOCALEDIR);
20408 textdomain (PACKAGE);
20409
20410 expandargv (&argc, &argv);
20411
20412 cmdline.file_name = "<cmdline>";
20413 parse_args (& cmdline, argc, argv);
20414
20415 if (optind < (argc - 1))
20416 show_name = TRUE;
20417 else if (optind >= argc)
20418 {
20419 warn (_("Nothing to do.\n"));
20420 usage (stderr);
20421 }
20422
20423 err = FALSE;
20424 while (optind < argc)
20425 if (! process_file (argv[optind++]))
20426 err = TRUE;
20427
20428 if (cmdline.dump_sects != NULL)
20429 free (cmdline.dump_sects);
20430
20431 free (dump_ctf_symtab_name);
20432 free (dump_ctf_strtab_name);
20433 free (dump_ctf_parent_name);
20434
20435 return err ? EXIT_FAILURE : EXIT_SUCCESS;
20436 }
This page took 0.658182 seconds and 4 git commands to generate.