1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2020 Free Software Foundation, Inc.
3
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
6
7 This file is part of GNU Binutils.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
22 02110-1301, USA. */
23
24 /* The difference between readelf and objdump:
25
26 Both programs are capable of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
28
29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
35
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
38
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
42
43 #include "sysdep.h"
44 #include <assert.h>
45 #include <time.h>
46 #include <zlib.h>
47 #ifdef HAVE_WCHAR_H
48 #include <wchar.h>
49 #endif
50
51 #if __GNUC__ >= 2
52 /* Define BFD64 here, even if our default architecture is 32 bit ELF
53 as this will allow us to read in and parse 64bit and 32bit ELF files.
54 Only do this if we believe that the compiler can support a 64 bit
55 data type. For now we only rely on GCC being able to do this. */
56 #define BFD64
57 #endif
58
59 #include "bfd.h"
60 #include "bucomm.h"
61 #include "elfcomm.h"
62 #include "dwarf.h"
63 #include "ctf-api.h"
64
65 #include "elf/common.h"
66 #include "elf/external.h"
67 #include "elf/internal.h"
68
69
70 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
71 we can obtain the H8 reloc numbers. We need these for the
72 get_reloc_size() function. We include h8.h again after defining
73 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
74
75 #include "elf/h8.h"
76 #undef _ELF_H8_H
77
78 /* Undo the effects of #including reloc-macros.h. */
79
80 #undef START_RELOC_NUMBERS
81 #undef RELOC_NUMBER
82 #undef FAKE_RELOC
83 #undef EMPTY_RELOC
84 #undef END_RELOC_NUMBERS
85 #undef _RELOC_MACROS_H
86
87 /* The following headers use the elf/reloc-macros.h file to
88 automatically generate relocation recognition functions
89 such as elf_mips_reloc_type() */
90
91 #define RELOC_MACROS_GEN_FUNC
92
93 #include "elf/aarch64.h"
94 #include "elf/alpha.h"
95 #include "elf/arc.h"
96 #include "elf/arm.h"
97 #include "elf/avr.h"
98 #include "elf/bfin.h"
99 #include "elf/cr16.h"
100 #include "elf/cris.h"
101 #include "elf/crx.h"
102 #include "elf/csky.h"
103 #include "elf/d10v.h"
104 #include "elf/d30v.h"
105 #include "elf/dlx.h"
106 #include "elf/bpf.h"
107 #include "elf/epiphany.h"
108 #include "elf/fr30.h"
109 #include "elf/frv.h"
110 #include "elf/ft32.h"
111 #include "elf/h8.h"
112 #include "elf/hppa.h"
113 #include "elf/i386.h"
114 #include "elf/i370.h"
115 #include "elf/i860.h"
116 #include "elf/i960.h"
117 #include "elf/ia64.h"
118 #include "elf/ip2k.h"
119 #include "elf/lm32.h"
120 #include "elf/iq2000.h"
121 #include "elf/m32c.h"
122 #include "elf/m32r.h"
123 #include "elf/m68k.h"
124 #include "elf/m68hc11.h"
125 #include "elf/s12z.h"
126 #include "elf/mcore.h"
127 #include "elf/mep.h"
128 #include "elf/metag.h"
129 #include "elf/microblaze.h"
130 #include "elf/mips.h"
131 #include "elf/mmix.h"
132 #include "elf/mn10200.h"
133 #include "elf/mn10300.h"
134 #include "elf/moxie.h"
135 #include "elf/mt.h"
136 #include "elf/msp430.h"
137 #include "elf/nds32.h"
138 #include "elf/nfp.h"
139 #include "elf/nios2.h"
140 #include "elf/or1k.h"
141 #include "elf/pj.h"
142 #include "elf/ppc.h"
143 #include "elf/ppc64.h"
144 #include "elf/pru.h"
145 #include "elf/riscv.h"
146 #include "elf/rl78.h"
147 #include "elf/rx.h"
148 #include "elf/s390.h"
149 #include "elf/score.h"
150 #include "elf/sh.h"
151 #include "elf/sparc.h"
152 #include "elf/spu.h"
153 #include "elf/tic6x.h"
154 #include "elf/tilegx.h"
155 #include "elf/tilepro.h"
156 #include "elf/v850.h"
157 #include "elf/vax.h"
158 #include "elf/visium.h"
159 #include "elf/wasm32.h"
160 #include "elf/x86-64.h"
161 #include "elf/xc16x.h"
162 #include "elf/xgate.h"
163 #include "elf/xstormy16.h"
164 #include "elf/xtensa.h"
165 #include "elf/z80.h"
166
167 #include "getopt.h"
168 #include "libiberty.h"
169 #include "safe-ctype.h"
170 #include "filenames.h"
171
172 #ifndef offsetof
173 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
174 #endif
175
176 typedef struct elf_section_list
177 {
178 Elf_Internal_Shdr * hdr;
179 struct elf_section_list * next;
180 } elf_section_list;
181
182 /* Flag bits indicating particular types of dump. */
183 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
184 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
185 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
186 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
187 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
188 #define CTF_DUMP (1 << 5) /* The --ctf command line switch. */
189
190 typedef unsigned char dump_type;
191
192 /* A linked list of the section names for which dumps were requested. */
193 struct dump_list_entry
194 {
195 char * name;
196 dump_type type;
197 struct dump_list_entry * next;
198 };
199
200 typedef struct filedata
201 {
202 const char * file_name;
203 FILE * handle;
204 bfd_size_type file_size;
205 Elf_Internal_Ehdr file_header;
206 Elf_Internal_Shdr * section_headers;
207 Elf_Internal_Phdr * program_headers;
208 char * string_table;
209 unsigned long string_table_length;
210 /* A dynamic array of flags indicating for which sections a dump of
211 some kind has been requested. It is reset on a per-object file
212 basis and then initialised from the cmdline_dump_sects array,
213 the results of interpreting the -w switch, and the
214 dump_sects_byname list. */
215 dump_type * dump_sects;
216 unsigned int num_dump_sects;
217 } Filedata;
218
219 char * program_name = "readelf";
220
221 static unsigned long archive_file_offset;
222 static unsigned long archive_file_size;
223 static unsigned long dynamic_addr;
224 static bfd_size_type dynamic_size;
225 static size_t dynamic_nent;
226 static char * dynamic_strings;
227 static unsigned long dynamic_strings_length;
228 static unsigned long num_dynamic_syms;
229 static Elf_Internal_Sym * dynamic_symbols;
230 static Elf_Internal_Syminfo * dynamic_syminfo;
231 static unsigned long dynamic_syminfo_offset;
232 static unsigned int dynamic_syminfo_nent;
233 static char program_interpreter[PATH_MAX];
234 static bfd_vma dynamic_info[DT_ENCODING];
235 static bfd_vma dynamic_info_DT_GNU_HASH;
236 static bfd_vma dynamic_info_DT_MIPS_XHASH;
237 static bfd_vma version_info[16];
238 static Elf_Internal_Dyn * dynamic_section;
239 static elf_section_list * symtab_shndx_list;
240 static bfd_boolean show_name = FALSE;
241 static bfd_boolean do_dynamic = FALSE;
242 static bfd_boolean do_syms = FALSE;
243 static bfd_boolean do_dyn_syms = FALSE;
244 static bfd_boolean do_reloc = FALSE;
245 static bfd_boolean do_sections = FALSE;
246 static bfd_boolean do_section_groups = FALSE;
247 static bfd_boolean do_section_details = FALSE;
248 static bfd_boolean do_segments = FALSE;
249 static bfd_boolean do_unwind = FALSE;
250 static bfd_boolean do_using_dynamic = FALSE;
251 static bfd_boolean do_header = FALSE;
252 static bfd_boolean do_dump = FALSE;
253 static bfd_boolean do_version = FALSE;
254 static bfd_boolean do_histogram = FALSE;
255 static bfd_boolean do_debugging = FALSE;
256 static bfd_boolean do_ctf = FALSE;
257 static bfd_boolean do_arch = FALSE;
258 static bfd_boolean do_notes = FALSE;
259 static bfd_boolean do_archive_index = FALSE;
260 static bfd_boolean is_32bit_elf = FALSE;
261 static bfd_boolean decompress_dumps = FALSE;
262
263 static char *dump_ctf_parent_name;
264 static char *dump_ctf_symtab_name;
265 static char *dump_ctf_strtab_name;
266
267 struct group_list
268 {
269 struct group_list * next;
270 unsigned int section_index;
271 };
272
273 struct group
274 {
275 struct group_list * root;
276 unsigned int group_index;
277 };
278
279 static size_t group_count;
280 static struct group * section_groups;
281 static struct group ** section_headers_groups;
282
283 /* A dynamic array of flags indicating for which sections a dump
284 has been requested via command line switches. */
285 static Filedata cmdline;
286
287 static struct dump_list_entry * dump_sects_byname;
288
289 /* How to print a vma value. */
290 typedef enum print_mode
291 {
292 HEX,
293 DEC,
294 DEC_5,
295 UNSIGNED,
296 PREFIX_HEX,
297 FULL_HEX,
298 LONG_HEX
299 }
300 print_mode;
301
302 /* Versioned symbol info. */
303 enum versioned_symbol_info
304 {
305 symbol_undefined,
306 symbol_hidden,
307 symbol_public
308 };
309
310 static const char * get_symbol_version_string
311 (Filedata *, bfd_boolean, const char *, unsigned long, unsigned,
312 Elf_Internal_Sym *, enum versioned_symbol_info *, unsigned short *);
313
314 #define UNKNOWN -1
315
316 #define SECTION_NAME(X) \
317 ((X) == NULL ? _("<none>") \
318 : filedata->string_table == NULL ? _("<no-strings>") \
319 : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>") \
320 : filedata->string_table + (X)->sh_name))
321
322 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
323
324 #define GET_ELF_SYMBOLS(file, section, sym_count) \
325 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
326 : get_64bit_elf_symbols (file, section, sym_count))
327
328 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
329 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
330 already been called and verified that the string exists. */
331 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
332
333 #define REMOVE_ARCH_BITS(ADDR) \
334 do \
335 { \
336 if (filedata->file_header.e_machine == EM_ARM) \
337 (ADDR) &= ~1; \
338 } \
339 while (0)
340
341 /* Get the correct GNU hash section name. */
342 #define GNU_HASH_SECTION_NAME \
343 dynamic_info_DT_MIPS_XHASH ? ".MIPS.xhash" : ".gnu.hash"
344
345 /* Print a BFD_VMA to an internal buffer, for use in error messages.
346 BFD_FMA_FMT can't be used in translated strings. */
347
348 static const char *
bfd_vmatoa(char * fmtch,bfd_vma value)349 bfd_vmatoa (char *fmtch, bfd_vma value)
350 {
351 /* bfd_vmatoa is used more then once in a printf call for output.
352 Cycle through an array of buffers. */
353 static int buf_pos = 0;
354 static struct bfd_vmatoa_buf
355 {
356 char place[64];
357 } buf[4];
358 char *ret;
359 char fmt[32];
360
361 ret = buf[buf_pos++].place;
362 buf_pos %= ARRAY_SIZE (buf);
363
364 sprintf (fmt, "%%%s%s", BFD_VMA_FMT, fmtch);
365 snprintf (ret, sizeof (buf[0].place), fmt, value);
366 return ret;
367 }
368
369 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
370 OFFSET + the offset of the current archive member, if we are examining an
371 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
372 allocate a buffer using malloc and fill that. In either case return the
373 pointer to the start of the retrieved data or NULL if something went wrong.
374 If something does go wrong and REASON is not NULL then emit an error
375 message using REASON as part of the context. */
376
377 static void *
get_data(void * var,Filedata * filedata,unsigned long offset,bfd_size_type size,bfd_size_type nmemb,const char * reason)378 get_data (void * var,
379 Filedata * filedata,
380 unsigned long offset,
381 bfd_size_type size,
382 bfd_size_type nmemb,
383 const char * reason)
384 {
385 void * mvar;
386 bfd_size_type amt = size * nmemb;
387
388 if (size == 0 || nmemb == 0)
389 return NULL;
390
391 /* If the size_t type is smaller than the bfd_size_type, eg because
392 you are building a 32-bit tool on a 64-bit host, then make sure
393 that when the sizes are cast to (size_t) no information is lost. */
394 if ((size_t) size != size
395 || (size_t) nmemb != nmemb
396 || (size_t) amt != amt)
397 {
398 if (reason)
399 error (_("Size truncation prevents reading %s"
400 " elements of size %s for %s\n"),
401 bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
402 return NULL;
403 }
404
405 /* Check for size overflow. */
406 if (amt / size != nmemb || (size_t) amt + 1 == 0)
407 {
408 if (reason)
409 error (_("Size overflow prevents reading %s"
410 " elements of size %s for %s\n"),
411 bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
412 return NULL;
413 }
414
415 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
416 attempting to allocate memory when the read is bound to fail. */
417 if (archive_file_offset > filedata->file_size
418 || offset > filedata->file_size - archive_file_offset
419 || amt > filedata->file_size - archive_file_offset - offset)
420 {
421 if (reason)
422 error (_("Reading %s bytes extends past end of file for %s\n"),
423 bfd_vmatoa ("u", amt), reason);
424 return NULL;
425 }
426
427 if (fseek (filedata->handle, archive_file_offset + offset, SEEK_SET))
428 {
429 if (reason)
430 error (_("Unable to seek to 0x%lx for %s\n"),
431 archive_file_offset + offset, reason);
432 return NULL;
433 }
434
435 mvar = var;
436 if (mvar == NULL)
437 {
438 /* + 1 so that we can '\0' terminate invalid string table sections. */
439 mvar = malloc ((size_t) amt + 1);
440
441 if (mvar == NULL)
442 {
443 if (reason)
444 error (_("Out of memory allocating %s bytes for %s\n"),
445 bfd_vmatoa ("u", amt), reason);
446 return NULL;
447 }
448
449 ((char *) mvar)[amt] = '\0';
450 }
451
452 if (fread (mvar, (size_t) size, (size_t) nmemb, filedata->handle) != nmemb)
453 {
454 if (reason)
455 error (_("Unable to read in %s bytes of %s\n"),
456 bfd_vmatoa ("u", amt), reason);
457 if (mvar != var)
458 free (mvar);
459 return NULL;
460 }
461
462 return mvar;
463 }
464
465 /* Print a VMA value in the MODE specified.
466 Returns the number of characters displayed. */
467
468 static unsigned int
print_vma(bfd_vma vma,print_mode mode)469 print_vma (bfd_vma vma, print_mode mode)
470 {
471 unsigned int nc = 0;
472
473 switch (mode)
474 {
475 case FULL_HEX:
476 nc = printf ("0x");
477 /* Fall through. */
478 case LONG_HEX:
479 #ifdef BFD64
480 if (is_32bit_elf)
481 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
482 #endif
483 printf_vma (vma);
484 return nc + 16;
485
486 case DEC_5:
487 if (vma <= 99999)
488 return printf ("%5" BFD_VMA_FMT "d", vma);
489 /* Fall through. */
490 case PREFIX_HEX:
491 nc = printf ("0x");
492 /* Fall through. */
493 case HEX:
494 return nc + printf ("%" BFD_VMA_FMT "x", vma);
495
496 case DEC:
497 return printf ("%" BFD_VMA_FMT "d", vma);
498
499 case UNSIGNED:
500 return printf ("%" BFD_VMA_FMT "u", vma);
501
502 default:
503 /* FIXME: Report unrecognised mode ? */
504 return 0;
505 }
506 }
507
508 /* Display a symbol on stdout. Handles the display of control characters and
509 multibye characters (assuming the host environment supports them).
510
511 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
512
513 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
514 padding as necessary.
515
516 Returns the number of emitted characters. */
517
518 static unsigned int
print_symbol(signed int width,const char * symbol)519 print_symbol (signed int width, const char *symbol)
520 {
521 bfd_boolean extra_padding = FALSE;
522 signed int num_printed = 0;
523 #ifdef HAVE_MBSTATE_T
524 mbstate_t state;
525 #endif
526 unsigned int width_remaining;
527
528 if (width < 0)
529 {
530 /* Keep the width positive. This helps the code below. */
531 width = - width;
532 extra_padding = TRUE;
533 }
534 else if (width == 0)
535 return 0;
536
537 if (do_wide)
538 /* Set the remaining width to a very large value.
539 This simplifies the code below. */
540 width_remaining = INT_MAX;
541 else
542 width_remaining = width;
543
544 #ifdef HAVE_MBSTATE_T
545 /* Initialise the multibyte conversion state. */
546 memset (& state, 0, sizeof (state));
547 #endif
548
549 while (width_remaining)
550 {
551 size_t n;
552 const char c = *symbol++;
553
554 if (c == 0)
555 break;
556
557 /* Do not print control characters directly as they can affect terminal
558 settings. Such characters usually appear in the names generated
559 by the assembler for local labels. */
560 if (ISCNTRL (c))
561 {
562 if (width_remaining < 2)
563 break;
564
565 printf ("^%c", c + 0x40);
566 width_remaining -= 2;
567 num_printed += 2;
568 }
569 else if (ISPRINT (c))
570 {
571 putchar (c);
572 width_remaining --;
573 num_printed ++;
574 }
575 else
576 {
577 #ifdef HAVE_MBSTATE_T
578 wchar_t w;
579 #endif
580 /* Let printf do the hard work of displaying multibyte characters. */
581 printf ("%.1s", symbol - 1);
582 width_remaining --;
583 num_printed ++;
584
585 #ifdef HAVE_MBSTATE_T
586 /* Try to find out how many bytes made up the character that was
587 just printed. Advance the symbol pointer past the bytes that
588 were displayed. */
589 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
590 #else
591 n = 1;
592 #endif
593 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
594 symbol += (n - 1);
595 }
596 }
597
598 if (extra_padding && num_printed < width)
599 {
600 /* Fill in the remaining spaces. */
601 printf ("%-*s", width - num_printed, " ");
602 num_printed = width;
603 }
604
605 return num_printed;
606 }
607
608 /* Returns a pointer to a static buffer containing a printable version of
609 the given section's name. Like print_symbol, except that it does not try
610 to print multibyte characters, it just interprets them as hex values. */
611
612 static const char *
printable_section_name(Filedata * filedata,const Elf_Internal_Shdr * sec)613 printable_section_name (Filedata * filedata, const Elf_Internal_Shdr * sec)
614 {
615 #define MAX_PRINT_SEC_NAME_LEN 128
616 static char sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
617 const char * name = SECTION_NAME (sec);
618 char * buf = sec_name_buf;
619 char c;
620 unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
621
622 while ((c = * name ++) != 0)
623 {
624 if (ISCNTRL (c))
625 {
626 if (remaining < 2)
627 break;
628
629 * buf ++ = '^';
630 * buf ++ = c + 0x40;
631 remaining -= 2;
632 }
633 else if (ISPRINT (c))
634 {
635 * buf ++ = c;
636 remaining -= 1;
637 }
638 else
639 {
640 static char hex[17] = "0123456789ABCDEF";
641
642 if (remaining < 4)
643 break;
644 * buf ++ = '<';
645 * buf ++ = hex[(c & 0xf0) >> 4];
646 * buf ++ = hex[c & 0x0f];
647 * buf ++ = '>';
648 remaining -= 4;
649 }
650
651 if (remaining == 0)
652 break;
653 }
654
655 * buf = 0;
656 return sec_name_buf;
657 }
658
659 static const char *
printable_section_name_from_index(Filedata * filedata,unsigned long ndx)660 printable_section_name_from_index (Filedata * filedata, unsigned long ndx)
661 {
662 if (ndx >= filedata->file_header.e_shnum)
663 return _("<corrupt>");
664
665 return printable_section_name (filedata, filedata->section_headers + ndx);
666 }
667
668 /* Return a pointer to section NAME, or NULL if no such section exists. */
669
670 static Elf_Internal_Shdr *
find_section(Filedata * filedata,const char * name)671 find_section (Filedata * filedata, const char * name)
672 {
673 unsigned int i;
674
675 if (filedata->section_headers == NULL)
676 return NULL;
677
678 for (i = 0; i < filedata->file_header.e_shnum; i++)
679 if (streq (SECTION_NAME (filedata->section_headers + i), name))
680 return filedata->section_headers + i;
681
682 return NULL;
683 }
684
685 /* Return a pointer to a section containing ADDR, or NULL if no such
686 section exists. */
687
688 static Elf_Internal_Shdr *
find_section_by_address(Filedata * filedata,bfd_vma addr)689 find_section_by_address (Filedata * filedata, bfd_vma addr)
690 {
691 unsigned int i;
692
693 if (filedata->section_headers == NULL)
694 return NULL;
695
696 for (i = 0; i < filedata->file_header.e_shnum; i++)
697 {
698 Elf_Internal_Shdr *sec = filedata->section_headers + i;
699
700 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
701 return sec;
702 }
703
704 return NULL;
705 }
706
707 static Elf_Internal_Shdr *
find_section_by_type(Filedata * filedata,unsigned int type)708 find_section_by_type (Filedata * filedata, unsigned int type)
709 {
710 unsigned int i;
711
712 if (filedata->section_headers == NULL)
713 return NULL;
714
715 for (i = 0; i < filedata->file_header.e_shnum; i++)
716 {
717 Elf_Internal_Shdr *sec = filedata->section_headers + i;
718
719 if (sec->sh_type == type)
720 return sec;
721 }
722
723 return NULL;
724 }
725
726 /* Return a pointer to section NAME, or NULL if no such section exists,
727 restricted to the list of sections given in SET. */
728
729 static Elf_Internal_Shdr *
find_section_in_set(Filedata * filedata,const char * name,unsigned int * set)730 find_section_in_set (Filedata * filedata, const char * name, unsigned int * set)
731 {
732 unsigned int i;
733
734 if (filedata->section_headers == NULL)
735 return NULL;
736
737 if (set != NULL)
738 {
739 while ((i = *set++) > 0)
740 {
741 /* See PR 21156 for a reproducer. */
742 if (i >= filedata->file_header.e_shnum)
743 continue; /* FIXME: Should we issue an error message ? */
744
745 if (streq (SECTION_NAME (filedata->section_headers + i), name))
746 return filedata->section_headers + i;
747 }
748 }
749
750 return find_section (filedata, name);
751 }
752
753 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
754 This OS has so many departures from the ELF standard that we test it at
755 many places. */
756
757 static inline bfd_boolean
is_ia64_vms(Filedata * filedata)758 is_ia64_vms (Filedata * filedata)
759 {
760 return filedata->file_header.e_machine == EM_IA_64
761 && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
762 }
763
764 /* Guess the relocation size commonly used by the specific machines. */
765
766 static bfd_boolean
guess_is_rela(unsigned int e_machine)767 guess_is_rela (unsigned int e_machine)
768 {
769 switch (e_machine)
770 {
771 /* Targets that use REL relocations. */
772 case EM_386:
773 case EM_IAMCU:
774 case EM_960:
775 case EM_ARM:
776 case EM_D10V:
777 case EM_CYGNUS_D10V:
778 case EM_DLX:
779 case EM_MIPS:
780 case EM_MIPS_RS3_LE:
781 case EM_CYGNUS_M32R:
782 case EM_SCORE:
783 case EM_XGATE:
784 case EM_NFP:
785 case EM_BPF:
786 return FALSE;
787
788 /* Targets that use RELA relocations. */
789 case EM_68K:
790 case EM_860:
791 case EM_AARCH64:
792 case EM_ADAPTEVA_EPIPHANY:
793 case EM_ALPHA:
794 case EM_ALTERA_NIOS2:
795 case EM_ARC:
796 case EM_ARC_COMPACT:
797 case EM_ARC_COMPACT2:
798 case EM_AVR:
799 case EM_AVR_OLD:
800 case EM_BLACKFIN:
801 case EM_CR16:
802 case EM_CRIS:
803 case EM_CRX:
804 case EM_CSKY:
805 case EM_D30V:
806 case EM_CYGNUS_D30V:
807 case EM_FR30:
808 case EM_FT32:
809 case EM_CYGNUS_FR30:
810 case EM_CYGNUS_FRV:
811 case EM_H8S:
812 case EM_H8_300:
813 case EM_H8_300H:
814 case EM_IA_64:
815 case EM_IP2K:
816 case EM_IP2K_OLD:
817 case EM_IQ2000:
818 case EM_LATTICEMICO32:
819 case EM_M32C_OLD:
820 case EM_M32C:
821 case EM_M32R:
822 case EM_MCORE:
823 case EM_CYGNUS_MEP:
824 case EM_METAG:
825 case EM_MMIX:
826 case EM_MN10200:
827 case EM_CYGNUS_MN10200:
828 case EM_MN10300:
829 case EM_CYGNUS_MN10300:
830 case EM_MOXIE:
831 case EM_MSP430:
832 case EM_MSP430_OLD:
833 case EM_MT:
834 case EM_NDS32:
835 case EM_NIOS32:
836 case EM_OR1K:
837 case EM_PPC64:
838 case EM_PPC:
839 case EM_TI_PRU:
840 case EM_RISCV:
841 case EM_RL78:
842 case EM_RX:
843 case EM_S390:
844 case EM_S390_OLD:
845 case EM_SH:
846 case EM_SPARC:
847 case EM_SPARC32PLUS:
848 case EM_SPARCV9:
849 case EM_SPU:
850 case EM_TI_C6000:
851 case EM_TILEGX:
852 case EM_TILEPRO:
853 case EM_V800:
854 case EM_V850:
855 case EM_CYGNUS_V850:
856 case EM_VAX:
857 case EM_VISIUM:
858 case EM_X86_64:
859 case EM_L1OM:
860 case EM_K1OM:
861 case EM_XSTORMY16:
862 case EM_XTENSA:
863 case EM_XTENSA_OLD:
864 case EM_MICROBLAZE:
865 case EM_MICROBLAZE_OLD:
866 case EM_WEBASSEMBLY:
867 return TRUE;
868
869 case EM_68HC05:
870 case EM_68HC08:
871 case EM_68HC11:
872 case EM_68HC16:
873 case EM_FX66:
874 case EM_ME16:
875 case EM_MMA:
876 case EM_NCPU:
877 case EM_NDR1:
878 case EM_PCP:
879 case EM_ST100:
880 case EM_ST19:
881 case EM_ST7:
882 case EM_ST9PLUS:
883 case EM_STARCORE:
884 case EM_SVX:
885 case EM_TINYJ:
886 default:
887 warn (_("Don't know about relocations on this machine architecture\n"));
888 return FALSE;
889 }
890 }
891
892 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
893 Returns TRUE upon success, FALSE otherwise. If successful then a
894 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
895 and the number of relocs loaded is placed in *NRELASP. It is the caller's
896 responsibility to free the allocated buffer. */
897
898 static bfd_boolean
slurp_rela_relocs(Filedata * filedata,unsigned long rel_offset,unsigned long rel_size,Elf_Internal_Rela ** relasp,unsigned long * nrelasp)899 slurp_rela_relocs (Filedata * filedata,
900 unsigned long rel_offset,
901 unsigned long rel_size,
902 Elf_Internal_Rela ** relasp,
903 unsigned long * nrelasp)
904 {
905 Elf_Internal_Rela * relas;
906 size_t nrelas;
907 unsigned int i;
908
909 if (is_32bit_elf)
910 {
911 Elf32_External_Rela * erelas;
912
913 erelas = (Elf32_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
914 rel_size, _("32-bit relocation data"));
915 if (!erelas)
916 return FALSE;
917
918 nrelas = rel_size / sizeof (Elf32_External_Rela);
919
920 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
921 sizeof (Elf_Internal_Rela));
922
923 if (relas == NULL)
924 {
925 free (erelas);
926 error (_("out of memory parsing relocs\n"));
927 return FALSE;
928 }
929
930 for (i = 0; i < nrelas; i++)
931 {
932 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
933 relas[i].r_info = BYTE_GET (erelas[i].r_info);
934 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
935 }
936
937 free (erelas);
938 }
939 else
940 {
941 Elf64_External_Rela * erelas;
942
943 erelas = (Elf64_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
944 rel_size, _("64-bit relocation data"));
945 if (!erelas)
946 return FALSE;
947
948 nrelas = rel_size / sizeof (Elf64_External_Rela);
949
950 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
951 sizeof (Elf_Internal_Rela));
952
953 if (relas == NULL)
954 {
955 free (erelas);
956 error (_("out of memory parsing relocs\n"));
957 return FALSE;
958 }
959
960 for (i = 0; i < nrelas; i++)
961 {
962 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
963 relas[i].r_info = BYTE_GET (erelas[i].r_info);
964 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
965
966 /* The #ifdef BFD64 below is to prevent a compile time
967 warning. We know that if we do not have a 64 bit data
968 type that we will never execute this code anyway. */
969 #ifdef BFD64
970 if (filedata->file_header.e_machine == EM_MIPS
971 && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
972 {
973 /* In little-endian objects, r_info isn't really a
974 64-bit little-endian value: it has a 32-bit
975 little-endian symbol index followed by four
976 individual byte fields. Reorder INFO
977 accordingly. */
978 bfd_vma inf = relas[i].r_info;
979 inf = (((inf & 0xffffffff) << 32)
980 | ((inf >> 56) & 0xff)
981 | ((inf >> 40) & 0xff00)
982 | ((inf >> 24) & 0xff0000)
983 | ((inf >> 8) & 0xff000000));
984 relas[i].r_info = inf;
985 }
986 #endif /* BFD64 */
987 }
988
989 free (erelas);
990 }
991
992 *relasp = relas;
993 *nrelasp = nrelas;
994 return TRUE;
995 }
996
997 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
998 Returns TRUE upon success, FALSE otherwise. If successful then a
999 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
1000 and the number of relocs loaded is placed in *NRELSP. It is the caller's
1001 responsibility to free the allocated buffer. */
1002
1003 static bfd_boolean
slurp_rel_relocs(Filedata * filedata,unsigned long rel_offset,unsigned long rel_size,Elf_Internal_Rela ** relsp,unsigned long * nrelsp)1004 slurp_rel_relocs (Filedata * filedata,
1005 unsigned long rel_offset,
1006 unsigned long rel_size,
1007 Elf_Internal_Rela ** relsp,
1008 unsigned long * nrelsp)
1009 {
1010 Elf_Internal_Rela * rels;
1011 size_t nrels;
1012 unsigned int i;
1013
1014 if (is_32bit_elf)
1015 {
1016 Elf32_External_Rel * erels;
1017
1018 erels = (Elf32_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1019 rel_size, _("32-bit relocation data"));
1020 if (!erels)
1021 return FALSE;
1022
1023 nrels = rel_size / sizeof (Elf32_External_Rel);
1024
1025 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1026
1027 if (rels == NULL)
1028 {
1029 free (erels);
1030 error (_("out of memory parsing relocs\n"));
1031 return FALSE;
1032 }
1033
1034 for (i = 0; i < nrels; i++)
1035 {
1036 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1037 rels[i].r_info = BYTE_GET (erels[i].r_info);
1038 rels[i].r_addend = 0;
1039 }
1040
1041 free (erels);
1042 }
1043 else
1044 {
1045 Elf64_External_Rel * erels;
1046
1047 erels = (Elf64_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1048 rel_size, _("64-bit relocation data"));
1049 if (!erels)
1050 return FALSE;
1051
1052 nrels = rel_size / sizeof (Elf64_External_Rel);
1053
1054 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1055
1056 if (rels == NULL)
1057 {
1058 free (erels);
1059 error (_("out of memory parsing relocs\n"));
1060 return FALSE;
1061 }
1062
1063 for (i = 0; i < nrels; i++)
1064 {
1065 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1066 rels[i].r_info = BYTE_GET (erels[i].r_info);
1067 rels[i].r_addend = 0;
1068
1069 /* The #ifdef BFD64 below is to prevent a compile time
1070 warning. We know that if we do not have a 64 bit data
1071 type that we will never execute this code anyway. */
1072 #ifdef BFD64
1073 if (filedata->file_header.e_machine == EM_MIPS
1074 && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
1075 {
1076 /* In little-endian objects, r_info isn't really a
1077 64-bit little-endian value: it has a 32-bit
1078 little-endian symbol index followed by four
1079 individual byte fields. Reorder INFO
1080 accordingly. */
1081 bfd_vma inf = rels[i].r_info;
1082 inf = (((inf & 0xffffffff) << 32)
1083 | ((inf >> 56) & 0xff)
1084 | ((inf >> 40) & 0xff00)
1085 | ((inf >> 24) & 0xff0000)
1086 | ((inf >> 8) & 0xff000000));
1087 rels[i].r_info = inf;
1088 }
1089 #endif /* BFD64 */
1090 }
1091
1092 free (erels);
1093 }
1094
1095 *relsp = rels;
1096 *nrelsp = nrels;
1097 return TRUE;
1098 }
1099
1100 /* Returns the reloc type extracted from the reloc info field. */
1101
1102 static unsigned int
get_reloc_type(Filedata * filedata,bfd_vma reloc_info)1103 get_reloc_type (Filedata * filedata, bfd_vma reloc_info)
1104 {
1105 if (is_32bit_elf)
1106 return ELF32_R_TYPE (reloc_info);
1107
1108 switch (filedata->file_header.e_machine)
1109 {
1110 case EM_MIPS:
1111 /* Note: We assume that reloc_info has already been adjusted for us. */
1112 return ELF64_MIPS_R_TYPE (reloc_info);
1113
1114 case EM_SPARCV9:
1115 return ELF64_R_TYPE_ID (reloc_info);
1116
1117 default:
1118 return ELF64_R_TYPE (reloc_info);
1119 }
1120 }
1121
1122 /* Return the symbol index extracted from the reloc info field. */
1123
1124 static bfd_vma
get_reloc_symindex(bfd_vma reloc_info)1125 get_reloc_symindex (bfd_vma reloc_info)
1126 {
1127 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1128 }
1129
1130 static inline bfd_boolean
uses_msp430x_relocs(Filedata * filedata)1131 uses_msp430x_relocs (Filedata * filedata)
1132 {
1133 return
1134 filedata->file_header.e_machine == EM_MSP430 /* Paranoia. */
1135 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1136 && (((filedata->file_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1137 /* TI compiler uses ELFOSABI_NONE. */
1138 || (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1139 }
1140
1141 /* Display the contents of the relocation data found at the specified
1142 offset. */
1143
1144 static bfd_boolean
dump_relocations(Filedata * filedata,unsigned long rel_offset,unsigned long rel_size,Elf_Internal_Sym * symtab,unsigned long nsyms,char * strtab,unsigned long strtablen,int is_rela,bfd_boolean is_dynsym)1145 dump_relocations (Filedata * filedata,
1146 unsigned long rel_offset,
1147 unsigned long rel_size,
1148 Elf_Internal_Sym * symtab,
1149 unsigned long nsyms,
1150 char * strtab,
1151 unsigned long strtablen,
1152 int is_rela,
1153 bfd_boolean is_dynsym)
1154 {
1155 unsigned long i;
1156 Elf_Internal_Rela * rels;
1157 bfd_boolean res = TRUE;
1158
1159 if (is_rela == UNKNOWN)
1160 is_rela = guess_is_rela (filedata->file_header.e_machine);
1161
1162 if (is_rela)
1163 {
1164 if (!slurp_rela_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1165 return FALSE;
1166 }
1167 else
1168 {
1169 if (!slurp_rel_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1170 return FALSE;
1171 }
1172
1173 if (is_32bit_elf)
1174 {
1175 if (is_rela)
1176 {
1177 if (do_wide)
1178 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1179 else
1180 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1181 }
1182 else
1183 {
1184 if (do_wide)
1185 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1186 else
1187 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1188 }
1189 }
1190 else
1191 {
1192 if (is_rela)
1193 {
1194 if (do_wide)
1195 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1196 else
1197 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1198 }
1199 else
1200 {
1201 if (do_wide)
1202 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1203 else
1204 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1205 }
1206 }
1207
1208 for (i = 0; i < rel_size; i++)
1209 {
1210 const char * rtype;
1211 bfd_vma offset;
1212 bfd_vma inf;
1213 bfd_vma symtab_index;
1214 bfd_vma type;
1215
1216 offset = rels[i].r_offset;
1217 inf = rels[i].r_info;
1218
1219 type = get_reloc_type (filedata, inf);
1220 symtab_index = get_reloc_symindex (inf);
1221
1222 if (is_32bit_elf)
1223 {
1224 printf ("%8.8lx %8.8lx ",
1225 (unsigned long) offset & 0xffffffff,
1226 (unsigned long) inf & 0xffffffff);
1227 }
1228 else
1229 {
1230 #if BFD_HOST_64BIT_LONG
1231 printf (do_wide
1232 ? "%16.16lx %16.16lx "
1233 : "%12.12lx %12.12lx ",
1234 offset, inf);
1235 #elif BFD_HOST_64BIT_LONG_LONG
1236 #ifndef __MSVCRT__
1237 printf (do_wide
1238 ? "%16.16llx %16.16llx "
1239 : "%12.12llx %12.12llx ",
1240 offset, inf);
1241 #else
1242 printf (do_wide
1243 ? "%16.16I64x %16.16I64x "
1244 : "%12.12I64x %12.12I64x ",
1245 offset, inf);
1246 #endif
1247 #else
1248 printf (do_wide
1249 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1250 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1251 _bfd_int64_high (offset),
1252 _bfd_int64_low (offset),
1253 _bfd_int64_high (inf),
1254 _bfd_int64_low (inf));
1255 #endif
1256 }
1257
1258 switch (filedata->file_header.e_machine)
1259 {
1260 default:
1261 rtype = NULL;
1262 break;
1263
1264 case EM_AARCH64:
1265 rtype = elf_aarch64_reloc_type (type);
1266 break;
1267
1268 case EM_M32R:
1269 case EM_CYGNUS_M32R:
1270 rtype = elf_m32r_reloc_type (type);
1271 break;
1272
1273 case EM_386:
1274 case EM_IAMCU:
1275 rtype = elf_i386_reloc_type (type);
1276 break;
1277
1278 case EM_68HC11:
1279 case EM_68HC12:
1280 rtype = elf_m68hc11_reloc_type (type);
1281 break;
1282
1283 case EM_S12Z:
1284 rtype = elf_s12z_reloc_type (type);
1285 break;
1286
1287 case EM_68K:
1288 rtype = elf_m68k_reloc_type (type);
1289 break;
1290
1291 case EM_960:
1292 rtype = elf_i960_reloc_type (type);
1293 break;
1294
1295 case EM_AVR:
1296 case EM_AVR_OLD:
1297 rtype = elf_avr_reloc_type (type);
1298 break;
1299
1300 case EM_OLD_SPARCV9:
1301 case EM_SPARC32PLUS:
1302 case EM_SPARCV9:
1303 case EM_SPARC:
1304 rtype = elf_sparc_reloc_type (type);
1305 break;
1306
1307 case EM_SPU:
1308 rtype = elf_spu_reloc_type (type);
1309 break;
1310
1311 case EM_V800:
1312 rtype = v800_reloc_type (type);
1313 break;
1314 case EM_V850:
1315 case EM_CYGNUS_V850:
1316 rtype = v850_reloc_type (type);
1317 break;
1318
1319 case EM_D10V:
1320 case EM_CYGNUS_D10V:
1321 rtype = elf_d10v_reloc_type (type);
1322 break;
1323
1324 case EM_D30V:
1325 case EM_CYGNUS_D30V:
1326 rtype = elf_d30v_reloc_type (type);
1327 break;
1328
1329 case EM_DLX:
1330 rtype = elf_dlx_reloc_type (type);
1331 break;
1332
1333 case EM_SH:
1334 rtype = elf_sh_reloc_type (type);
1335 break;
1336
1337 case EM_MN10300:
1338 case EM_CYGNUS_MN10300:
1339 rtype = elf_mn10300_reloc_type (type);
1340 break;
1341
1342 case EM_MN10200:
1343 case EM_CYGNUS_MN10200:
1344 rtype = elf_mn10200_reloc_type (type);
1345 break;
1346
1347 case EM_FR30:
1348 case EM_CYGNUS_FR30:
1349 rtype = elf_fr30_reloc_type (type);
1350 break;
1351
1352 case EM_CYGNUS_FRV:
1353 rtype = elf_frv_reloc_type (type);
1354 break;
1355
1356 case EM_CSKY:
1357 rtype = elf_csky_reloc_type (type);
1358 break;
1359
1360 case EM_FT32:
1361 rtype = elf_ft32_reloc_type (type);
1362 break;
1363
1364 case EM_MCORE:
1365 rtype = elf_mcore_reloc_type (type);
1366 break;
1367
1368 case EM_MMIX:
1369 rtype = elf_mmix_reloc_type (type);
1370 break;
1371
1372 case EM_MOXIE:
1373 rtype = elf_moxie_reloc_type (type);
1374 break;
1375
1376 case EM_MSP430:
1377 if (uses_msp430x_relocs (filedata))
1378 {
1379 rtype = elf_msp430x_reloc_type (type);
1380 break;
1381 }
1382 /* Fall through. */
1383 case EM_MSP430_OLD:
1384 rtype = elf_msp430_reloc_type (type);
1385 break;
1386
1387 case EM_NDS32:
1388 rtype = elf_nds32_reloc_type (type);
1389 break;
1390
1391 case EM_PPC:
1392 rtype = elf_ppc_reloc_type (type);
1393 break;
1394
1395 case EM_PPC64:
1396 rtype = elf_ppc64_reloc_type (type);
1397 break;
1398
1399 case EM_MIPS:
1400 case EM_MIPS_RS3_LE:
1401 rtype = elf_mips_reloc_type (type);
1402 break;
1403
1404 case EM_RISCV:
1405 rtype = elf_riscv_reloc_type (type);
1406 break;
1407
1408 case EM_ALPHA:
1409 rtype = elf_alpha_reloc_type (type);
1410 break;
1411
1412 case EM_ARM:
1413 rtype = elf_arm_reloc_type (type);
1414 break;
1415
1416 case EM_ARC:
1417 case EM_ARC_COMPACT:
1418 case EM_ARC_COMPACT2:
1419 rtype = elf_arc_reloc_type (type);
1420 break;
1421
1422 case EM_PARISC:
1423 rtype = elf_hppa_reloc_type (type);
1424 break;
1425
1426 case EM_H8_300:
1427 case EM_H8_300H:
1428 case EM_H8S:
1429 rtype = elf_h8_reloc_type (type);
1430 break;
1431
1432 case EM_OR1K:
1433 rtype = elf_or1k_reloc_type (type);
1434 break;
1435
1436 case EM_PJ:
1437 case EM_PJ_OLD:
1438 rtype = elf_pj_reloc_type (type);
1439 break;
1440 case EM_IA_64:
1441 rtype = elf_ia64_reloc_type (type);
1442 break;
1443
1444 case EM_CRIS:
1445 rtype = elf_cris_reloc_type (type);
1446 break;
1447
1448 case EM_860:
1449 rtype = elf_i860_reloc_type (type);
1450 break;
1451
1452 case EM_X86_64:
1453 case EM_L1OM:
1454 case EM_K1OM:
1455 rtype = elf_x86_64_reloc_type (type);
1456 break;
1457
1458 case EM_S370:
1459 rtype = i370_reloc_type (type);
1460 break;
1461
1462 case EM_S390_OLD:
1463 case EM_S390:
1464 rtype = elf_s390_reloc_type (type);
1465 break;
1466
1467 case EM_SCORE:
1468 rtype = elf_score_reloc_type (type);
1469 break;
1470
1471 case EM_XSTORMY16:
1472 rtype = elf_xstormy16_reloc_type (type);
1473 break;
1474
1475 case EM_CRX:
1476 rtype = elf_crx_reloc_type (type);
1477 break;
1478
1479 case EM_VAX:
1480 rtype = elf_vax_reloc_type (type);
1481 break;
1482
1483 case EM_VISIUM:
1484 rtype = elf_visium_reloc_type (type);
1485 break;
1486
1487 case EM_BPF:
1488 rtype = elf_bpf_reloc_type (type);
1489 break;
1490
1491 case EM_ADAPTEVA_EPIPHANY:
1492 rtype = elf_epiphany_reloc_type (type);
1493 break;
1494
1495 case EM_IP2K:
1496 case EM_IP2K_OLD:
1497 rtype = elf_ip2k_reloc_type (type);
1498 break;
1499
1500 case EM_IQ2000:
1501 rtype = elf_iq2000_reloc_type (type);
1502 break;
1503
1504 case EM_XTENSA_OLD:
1505 case EM_XTENSA:
1506 rtype = elf_xtensa_reloc_type (type);
1507 break;
1508
1509 case EM_LATTICEMICO32:
1510 rtype = elf_lm32_reloc_type (type);
1511 break;
1512
1513 case EM_M32C_OLD:
1514 case EM_M32C:
1515 rtype = elf_m32c_reloc_type (type);
1516 break;
1517
1518 case EM_MT:
1519 rtype = elf_mt_reloc_type (type);
1520 break;
1521
1522 case EM_BLACKFIN:
1523 rtype = elf_bfin_reloc_type (type);
1524 break;
1525
1526 case EM_CYGNUS_MEP:
1527 rtype = elf_mep_reloc_type (type);
1528 break;
1529
1530 case EM_CR16:
1531 rtype = elf_cr16_reloc_type (type);
1532 break;
1533
1534 case EM_MICROBLAZE:
1535 case EM_MICROBLAZE_OLD:
1536 rtype = elf_microblaze_reloc_type (type);
1537 break;
1538
1539 case EM_RL78:
1540 rtype = elf_rl78_reloc_type (type);
1541 break;
1542
1543 case EM_RX:
1544 rtype = elf_rx_reloc_type (type);
1545 break;
1546
1547 case EM_METAG:
1548 rtype = elf_metag_reloc_type (type);
1549 break;
1550
1551 case EM_XC16X:
1552 case EM_C166:
1553 rtype = elf_xc16x_reloc_type (type);
1554 break;
1555
1556 case EM_TI_C6000:
1557 rtype = elf_tic6x_reloc_type (type);
1558 break;
1559
1560 case EM_TILEGX:
1561 rtype = elf_tilegx_reloc_type (type);
1562 break;
1563
1564 case EM_TILEPRO:
1565 rtype = elf_tilepro_reloc_type (type);
1566 break;
1567
1568 case EM_WEBASSEMBLY:
1569 rtype = elf_wasm32_reloc_type (type);
1570 break;
1571
1572 case EM_XGATE:
1573 rtype = elf_xgate_reloc_type (type);
1574 break;
1575
1576 case EM_ALTERA_NIOS2:
1577 rtype = elf_nios2_reloc_type (type);
1578 break;
1579
1580 case EM_TI_PRU:
1581 rtype = elf_pru_reloc_type (type);
1582 break;
1583
1584 case EM_NFP:
1585 if (EF_NFP_MACH (filedata->file_header.e_flags) == E_NFP_MACH_3200)
1586 rtype = elf_nfp3200_reloc_type (type);
1587 else
1588 rtype = elf_nfp_reloc_type (type);
1589 break;
1590
1591 case EM_Z80:
1592 rtype = elf_z80_reloc_type (type);
1593 break;
1594 }
1595
1596 if (rtype == NULL)
1597 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1598 else
1599 printf (do_wide ? "%-22s" : "%-17.17s", rtype);
1600
1601 if (filedata->file_header.e_machine == EM_ALPHA
1602 && rtype != NULL
1603 && streq (rtype, "R_ALPHA_LITUSE")
1604 && is_rela)
1605 {
1606 switch (rels[i].r_addend)
1607 {
1608 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1609 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1610 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1611 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1612 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1613 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1614 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1615 default: rtype = NULL;
1616 }
1617
1618 if (rtype)
1619 printf (" (%s)", rtype);
1620 else
1621 {
1622 putchar (' ');
1623 printf (_("<unknown addend: %lx>"),
1624 (unsigned long) rels[i].r_addend);
1625 res = FALSE;
1626 }
1627 }
1628 else if (symtab_index)
1629 {
1630 if (symtab == NULL || symtab_index >= nsyms)
1631 {
1632 error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index);
1633 res = FALSE;
1634 }
1635 else
1636 {
1637 Elf_Internal_Sym * psym;
1638 const char * version_string;
1639 enum versioned_symbol_info sym_info;
1640 unsigned short vna_other;
1641
1642 psym = symtab + symtab_index;
1643
1644 version_string
1645 = get_symbol_version_string (filedata, is_dynsym,
1646 strtab, strtablen,
1647 symtab_index,
1648 psym,
1649 &sym_info,
1650 &vna_other);
1651
1652 printf (" ");
1653
1654 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1655 {
1656 const char * name;
1657 unsigned int len;
1658 unsigned int width = is_32bit_elf ? 8 : 14;
1659
1660 /* Relocations against GNU_IFUNC symbols do not use the value
1661 of the symbol as the address to relocate against. Instead
1662 they invoke the function named by the symbol and use its
1663 result as the address for relocation.
1664
1665 To indicate this to the user, do not display the value of
1666 the symbol in the "Symbols's Value" field. Instead show
1667 its name followed by () as a hint that the symbol is
1668 invoked. */
1669
1670 if (strtab == NULL
1671 || psym->st_name == 0
1672 || psym->st_name >= strtablen)
1673 name = "??";
1674 else
1675 name = strtab + psym->st_name;
1676
1677 len = print_symbol (width, name);
1678 if (version_string)
1679 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1680 version_string);
1681 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1682 }
1683 else
1684 {
1685 print_vma (psym->st_value, LONG_HEX);
1686
1687 printf (is_32bit_elf ? " " : " ");
1688 }
1689
1690 if (psym->st_name == 0)
1691 {
1692 const char * sec_name = "<null>";
1693 char name_buf[40];
1694
1695 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1696 {
1697 if (psym->st_shndx < filedata->file_header.e_shnum)
1698 sec_name = SECTION_NAME (filedata->section_headers + psym->st_shndx);
1699 else if (psym->st_shndx == SHN_ABS)
1700 sec_name = "ABS";
1701 else if (psym->st_shndx == SHN_COMMON)
1702 sec_name = "COMMON";
1703 else if ((filedata->file_header.e_machine == EM_MIPS
1704 && psym->st_shndx == SHN_MIPS_SCOMMON)
1705 || (filedata->file_header.e_machine == EM_TI_C6000
1706 && psym->st_shndx == SHN_TIC6X_SCOMMON))
1707 sec_name = "SCOMMON";
1708 else if (filedata->file_header.e_machine == EM_MIPS
1709 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1710 sec_name = "SUNDEF";
1711 else if ((filedata->file_header.e_machine == EM_X86_64
1712 || filedata->file_header.e_machine == EM_L1OM
1713 || filedata->file_header.e_machine == EM_K1OM)
1714 && psym->st_shndx == SHN_X86_64_LCOMMON)
1715 sec_name = "LARGE_COMMON";
1716 else if (filedata->file_header.e_machine == EM_IA_64
1717 && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1718 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1719 sec_name = "ANSI_COM";
1720 else if (is_ia64_vms (filedata)
1721 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1722 sec_name = "VMS_SYMVEC";
1723 else
1724 {
1725 sprintf (name_buf, "<section 0x%x>",
1726 (unsigned int) psym->st_shndx);
1727 sec_name = name_buf;
1728 }
1729 }
1730 print_symbol (22, sec_name);
1731 }
1732 else if (strtab == NULL)
1733 printf (_("<string table index: %3ld>"), psym->st_name);
1734 else if (psym->st_name >= strtablen)
1735 {
1736 error (_("<corrupt string table index: %3ld>"), psym->st_name);
1737 res = FALSE;
1738 }
1739 else
1740 {
1741 print_symbol (22, strtab + psym->st_name);
1742 if (version_string)
1743 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1744 version_string);
1745 }
1746
1747 if (is_rela)
1748 {
1749 bfd_vma off = rels[i].r_addend;
1750
1751 if ((bfd_signed_vma) off < 0)
1752 printf (" - %" BFD_VMA_FMT "x", - off);
1753 else
1754 printf (" + %" BFD_VMA_FMT "x", off);
1755 }
1756 }
1757 }
1758 else if (is_rela)
1759 {
1760 bfd_vma off = rels[i].r_addend;
1761
1762 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1763 if ((bfd_signed_vma) off < 0)
1764 printf ("-%" BFD_VMA_FMT "x", - off);
1765 else
1766 printf ("%" BFD_VMA_FMT "x", off);
1767 }
1768
1769 if (filedata->file_header.e_machine == EM_SPARCV9
1770 && rtype != NULL
1771 && streq (rtype, "R_SPARC_OLO10"))
1772 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1773
1774 putchar ('\n');
1775
1776 #ifdef BFD64
1777 if (! is_32bit_elf && filedata->file_header.e_machine == EM_MIPS)
1778 {
1779 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1780 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1781 const char * rtype2 = elf_mips_reloc_type (type2);
1782 const char * rtype3 = elf_mips_reloc_type (type3);
1783
1784 printf (" Type2: ");
1785
1786 if (rtype2 == NULL)
1787 printf (_("unrecognized: %-7lx"),
1788 (unsigned long) type2 & 0xffffffff);
1789 else
1790 printf ("%-17.17s", rtype2);
1791
1792 printf ("\n Type3: ");
1793
1794 if (rtype3 == NULL)
1795 printf (_("unrecognized: %-7lx"),
1796 (unsigned long) type3 & 0xffffffff);
1797 else
1798 printf ("%-17.17s", rtype3);
1799
1800 putchar ('\n');
1801 }
1802 #endif /* BFD64 */
1803 }
1804
1805 free (rels);
1806
1807 return res;
1808 }
1809
1810 static const char *
get_aarch64_dynamic_type(unsigned long type)1811 get_aarch64_dynamic_type (unsigned long type)
1812 {
1813 switch (type)
1814 {
1815 case DT_AARCH64_BTI_PLT: return "AARCH64_BTI_PLT";
1816 case DT_AARCH64_PAC_PLT: return "AARCH64_PAC_PLT";
1817 case DT_AARCH64_VARIANT_PCS: return "AARCH64_VARIANT_PCS";
1818 default:
1819 return NULL;
1820 }
1821 }
1822
1823 static const char *
get_mips_dynamic_type(unsigned long type)1824 get_mips_dynamic_type (unsigned long type)
1825 {
1826 switch (type)
1827 {
1828 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1829 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1830 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1831 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1832 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1833 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1834 case DT_MIPS_MSYM: return "MIPS_MSYM";
1835 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1836 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1837 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1838 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1839 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1840 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1841 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1842 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1843 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1844 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1845 case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
1846 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1847 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1848 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1849 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1850 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1851 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1852 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1853 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1854 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1855 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1856 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1857 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1858 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1859 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1860 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1861 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1862 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1863 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1864 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1865 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1866 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1867 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1868 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1869 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1870 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1871 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1872 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1873 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1874 case DT_MIPS_XHASH: return "MIPS_XHASH";
1875 default:
1876 return NULL;
1877 }
1878 }
1879
1880 static const char *
get_sparc64_dynamic_type(unsigned long type)1881 get_sparc64_dynamic_type (unsigned long type)
1882 {
1883 switch (type)
1884 {
1885 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1886 default:
1887 return NULL;
1888 }
1889 }
1890
1891 static const char *
get_ppc_dynamic_type(unsigned long type)1892 get_ppc_dynamic_type (unsigned long type)
1893 {
1894 switch (type)
1895 {
1896 case DT_PPC_GOT: return "PPC_GOT";
1897 case DT_PPC_OPT: return "PPC_OPT";
1898 default:
1899 return NULL;
1900 }
1901 }
1902
1903 static const char *
get_ppc64_dynamic_type(unsigned long type)1904 get_ppc64_dynamic_type (unsigned long type)
1905 {
1906 switch (type)
1907 {
1908 case DT_PPC64_GLINK: return "PPC64_GLINK";
1909 case DT_PPC64_OPD: return "PPC64_OPD";
1910 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1911 case DT_PPC64_OPT: return "PPC64_OPT";
1912 default:
1913 return NULL;
1914 }
1915 }
1916
1917 static const char *
get_parisc_dynamic_type(unsigned long type)1918 get_parisc_dynamic_type (unsigned long type)
1919 {
1920 switch (type)
1921 {
1922 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1923 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1924 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1925 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1926 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1927 case DT_HP_PREINIT: return "HP_PREINIT";
1928 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1929 case DT_HP_NEEDED: return "HP_NEEDED";
1930 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1931 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1932 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1933 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1934 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1935 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1936 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1937 case DT_HP_FILTERED: return "HP_FILTERED";
1938 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1939 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1940 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1941 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1942 case DT_PLT: return "PLT";
1943 case DT_PLT_SIZE: return "PLT_SIZE";
1944 case DT_DLT: return "DLT";
1945 case DT_DLT_SIZE: return "DLT_SIZE";
1946 default:
1947 return NULL;
1948 }
1949 }
1950
1951 static const char *
get_ia64_dynamic_type(unsigned long type)1952 get_ia64_dynamic_type (unsigned long type)
1953 {
1954 switch (type)
1955 {
1956 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1957 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1958 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1959 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1960 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1961 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1962 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1963 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1964 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1965 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1966 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1967 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1968 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1969 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1970 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1971 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1972 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1973 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1974 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1975 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1976 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1977 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1978 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1979 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1980 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1981 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1982 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1983 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1984 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1985 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1986 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
1987 default:
1988 return NULL;
1989 }
1990 }
1991
1992 static const char *
get_solaris_section_type(unsigned long type)1993 get_solaris_section_type (unsigned long type)
1994 {
1995 switch (type)
1996 {
1997 case 0x6fffffee: return "SUNW_ancillary";
1998 case 0x6fffffef: return "SUNW_capchain";
1999 case 0x6ffffff0: return "SUNW_capinfo";
2000 case 0x6ffffff1: return "SUNW_symsort";
2001 case 0x6ffffff2: return "SUNW_tlssort";
2002 case 0x6ffffff3: return "SUNW_LDYNSYM";
2003 case 0x6ffffff4: return "SUNW_dof";
2004 case 0x6ffffff5: return "SUNW_cap";
2005 case 0x6ffffff6: return "SUNW_SIGNATURE";
2006 case 0x6ffffff7: return "SUNW_ANNOTATE";
2007 case 0x6ffffff8: return "SUNW_DEBUGSTR";
2008 case 0x6ffffff9: return "SUNW_DEBUG";
2009 case 0x6ffffffa: return "SUNW_move";
2010 case 0x6ffffffb: return "SUNW_COMDAT";
2011 case 0x6ffffffc: return "SUNW_syminfo";
2012 case 0x6ffffffd: return "SUNW_verdef";
2013 case 0x6ffffffe: return "SUNW_verneed";
2014 case 0x6fffffff: return "SUNW_versym";
2015 case 0x70000000: return "SPARC_GOTDATA";
2016 default: return NULL;
2017 }
2018 }
2019
2020 static const char *
get_alpha_dynamic_type(unsigned long type)2021 get_alpha_dynamic_type (unsigned long type)
2022 {
2023 switch (type)
2024 {
2025 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
2026 default: return NULL;
2027 }
2028 }
2029
2030 static const char *
get_score_dynamic_type(unsigned long type)2031 get_score_dynamic_type (unsigned long type)
2032 {
2033 switch (type)
2034 {
2035 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
2036 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
2037 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
2038 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
2039 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
2040 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
2041 default: return NULL;
2042 }
2043 }
2044
2045 static const char *
get_tic6x_dynamic_type(unsigned long type)2046 get_tic6x_dynamic_type (unsigned long type)
2047 {
2048 switch (type)
2049 {
2050 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
2051 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
2052 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
2053 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
2054 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
2055 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
2056 default: return NULL;
2057 }
2058 }
2059
2060 static const char *
get_nios2_dynamic_type(unsigned long type)2061 get_nios2_dynamic_type (unsigned long type)
2062 {
2063 switch (type)
2064 {
2065 case DT_NIOS2_GP: return "NIOS2_GP";
2066 default: return NULL;
2067 }
2068 }
2069
2070 static const char *
get_solaris_dynamic_type(unsigned long type)2071 get_solaris_dynamic_type (unsigned long type)
2072 {
2073 switch (type)
2074 {
2075 case 0x6000000d: return "SUNW_AUXILIARY";
2076 case 0x6000000e: return "SUNW_RTLDINF";
2077 case 0x6000000f: return "SUNW_FILTER";
2078 case 0x60000010: return "SUNW_CAP";
2079 case 0x60000011: return "SUNW_SYMTAB";
2080 case 0x60000012: return "SUNW_SYMSZ";
2081 case 0x60000013: return "SUNW_SORTENT";
2082 case 0x60000014: return "SUNW_SYMSORT";
2083 case 0x60000015: return "SUNW_SYMSORTSZ";
2084 case 0x60000016: return "SUNW_TLSSORT";
2085 case 0x60000017: return "SUNW_TLSSORTSZ";
2086 case 0x60000018: return "SUNW_CAPINFO";
2087 case 0x60000019: return "SUNW_STRPAD";
2088 case 0x6000001a: return "SUNW_CAPCHAIN";
2089 case 0x6000001b: return "SUNW_LDMACH";
2090 case 0x6000001d: return "SUNW_CAPCHAINENT";
2091 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2092 case 0x60000021: return "SUNW_PARENT";
2093 case 0x60000023: return "SUNW_ASLR";
2094 case 0x60000025: return "SUNW_RELAX";
2095 case 0x60000029: return "SUNW_NXHEAP";
2096 case 0x6000002b: return "SUNW_NXSTACK";
2097
2098 case 0x70000001: return "SPARC_REGISTER";
2099 case 0x7ffffffd: return "AUXILIARY";
2100 case 0x7ffffffe: return "USED";
2101 case 0x7fffffff: return "FILTER";
2102
2103 default: return NULL;
2104 }
2105 }
2106
2107 static const char *
get_dynamic_type(Filedata * filedata,unsigned long type)2108 get_dynamic_type (Filedata * filedata, unsigned long type)
2109 {
2110 static char buff[64];
2111
2112 switch (type)
2113 {
2114 case DT_NULL: return "NULL";
2115 case DT_NEEDED: return "NEEDED";
2116 case DT_PLTRELSZ: return "PLTRELSZ";
2117 case DT_PLTGOT: return "PLTGOT";
2118 case DT_HASH: return "HASH";
2119 case DT_STRTAB: return "STRTAB";
2120 case DT_SYMTAB: return "SYMTAB";
2121 case DT_RELA: return "RELA";
2122 case DT_RELASZ: return "RELASZ";
2123 case DT_RELAENT: return "RELAENT";
2124 case DT_STRSZ: return "STRSZ";
2125 case DT_SYMENT: return "SYMENT";
2126 case DT_INIT: return "INIT";
2127 case DT_FINI: return "FINI";
2128 case DT_SONAME: return "SONAME";
2129 case DT_RPATH: return "RPATH";
2130 case DT_SYMBOLIC: return "SYMBOLIC";
2131 case DT_REL: return "REL";
2132 case DT_RELSZ: return "RELSZ";
2133 case DT_RELENT: return "RELENT";
2134 case DT_PLTREL: return "PLTREL";
2135 case DT_DEBUG: return "DEBUG";
2136 case DT_TEXTREL: return "TEXTREL";
2137 case DT_JMPREL: return "JMPREL";
2138 case DT_BIND_NOW: return "BIND_NOW";
2139 case DT_INIT_ARRAY: return "INIT_ARRAY";
2140 case DT_FINI_ARRAY: return "FINI_ARRAY";
2141 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
2142 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
2143 case DT_RUNPATH: return "RUNPATH";
2144 case DT_FLAGS: return "FLAGS";
2145
2146 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2147 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
2148 case DT_SYMTAB_SHNDX: return "SYMTAB_SHNDX";
2149
2150 case DT_CHECKSUM: return "CHECKSUM";
2151 case DT_PLTPADSZ: return "PLTPADSZ";
2152 case DT_MOVEENT: return "MOVEENT";
2153 case DT_MOVESZ: return "MOVESZ";
2154 case DT_FEATURE: return "FEATURE";
2155 case DT_POSFLAG_1: return "POSFLAG_1";
2156 case DT_SYMINSZ: return "SYMINSZ";
2157 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
2158
2159 case DT_ADDRRNGLO: return "ADDRRNGLO";
2160 case DT_CONFIG: return "CONFIG";
2161 case DT_DEPAUDIT: return "DEPAUDIT";
2162 case DT_AUDIT: return "AUDIT";
2163 case DT_PLTPAD: return "PLTPAD";
2164 case DT_MOVETAB: return "MOVETAB";
2165 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
2166
2167 case DT_VERSYM: return "VERSYM";
2168
2169 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
2170 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
2171 case DT_RELACOUNT: return "RELACOUNT";
2172 case DT_RELCOUNT: return "RELCOUNT";
2173 case DT_FLAGS_1: return "FLAGS_1";
2174 case DT_VERDEF: return "VERDEF";
2175 case DT_VERDEFNUM: return "VERDEFNUM";
2176 case DT_VERNEED: return "VERNEED";
2177 case DT_VERNEEDNUM: return "VERNEEDNUM";
2178
2179 case DT_AUXILIARY: return "AUXILIARY";
2180 case DT_USED: return "USED";
2181 case DT_FILTER: return "FILTER";
2182
2183 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
2184 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
2185 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
2186 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
2187 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
2188 case DT_GNU_HASH: return "GNU_HASH";
2189
2190 default:
2191 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
2192 {
2193 const char * result;
2194
2195 switch (filedata->file_header.e_machine)
2196 {
2197 case EM_AARCH64:
2198 result = get_aarch64_dynamic_type (type);
2199 break;
2200 case EM_MIPS:
2201 case EM_MIPS_RS3_LE:
2202 result = get_mips_dynamic_type (type);
2203 break;
2204 case EM_SPARCV9:
2205 result = get_sparc64_dynamic_type (type);
2206 break;
2207 case EM_PPC:
2208 result = get_ppc_dynamic_type (type);
2209 break;
2210 case EM_PPC64:
2211 result = get_ppc64_dynamic_type (type);
2212 break;
2213 case EM_IA_64:
2214 result = get_ia64_dynamic_type (type);
2215 break;
2216 case EM_ALPHA:
2217 result = get_alpha_dynamic_type (type);
2218 break;
2219 case EM_SCORE:
2220 result = get_score_dynamic_type (type);
2221 break;
2222 case EM_TI_C6000:
2223 result = get_tic6x_dynamic_type (type);
2224 break;
2225 case EM_ALTERA_NIOS2:
2226 result = get_nios2_dynamic_type (type);
2227 break;
2228 default:
2229 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2230 result = get_solaris_dynamic_type (type);
2231 else
2232 result = NULL;
2233 break;
2234 }
2235
2236 if (result != NULL)
2237 return result;
2238
2239 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2240 }
2241 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2242 || (filedata->file_header.e_machine == EM_PARISC
2243 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
2244 {
2245 const char * result;
2246
2247 switch (filedata->file_header.e_machine)
2248 {
2249 case EM_PARISC:
2250 result = get_parisc_dynamic_type (type);
2251 break;
2252 case EM_IA_64:
2253 result = get_ia64_dynamic_type (type);
2254 break;
2255 default:
2256 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2257 result = get_solaris_dynamic_type (type);
2258 else
2259 result = NULL;
2260 break;
2261 }
2262
2263 if (result != NULL)
2264 return result;
2265
2266 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2267 type);
2268 }
2269 else
2270 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2271
2272 return buff;
2273 }
2274 }
2275
2276 static char *
get_file_type(unsigned e_type)2277 get_file_type (unsigned e_type)
2278 {
2279 static char buff[32];
2280
2281 switch (e_type)
2282 {
2283 case ET_NONE: return _("NONE (None)");
2284 case ET_REL: return _("REL (Relocatable file)");
2285 case ET_EXEC: return _("EXEC (Executable file)");
2286 case ET_DYN: return _("DYN (Shared object file)");
2287 case ET_CORE: return _("CORE (Core file)");
2288
2289 default:
2290 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2291 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2292 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2293 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2294 else
2295 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2296 return buff;
2297 }
2298 }
2299
2300 static char *
get_machine_name(unsigned e_machine)2301 get_machine_name (unsigned e_machine)
2302 {
2303 static char buff[64]; /* XXX */
2304
2305 switch (e_machine)
2306 {
2307 /* Please keep this switch table sorted by increasing EM_ value. */
2308 /* 0 */
2309 case EM_NONE: return _("None");
2310 case EM_M32: return "WE32100";
2311 case EM_SPARC: return "Sparc";
2312 case EM_386: return "Intel 80386";
2313 case EM_68K: return "MC68000";
2314 case EM_88K: return "MC88000";
2315 case EM_IAMCU: return "Intel MCU";
2316 case EM_860: return "Intel 80860";
2317 case EM_MIPS: return "MIPS R3000";
2318 case EM_S370: return "IBM System/370";
2319 /* 10 */
2320 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
2321 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
2322 case EM_PARISC: return "HPPA";
2323 case EM_VPP550: return "Fujitsu VPP500";
2324 case EM_SPARC32PLUS: return "Sparc v8+" ;
2325 case EM_960: return "Intel 80960";
2326 case EM_PPC: return "PowerPC";
2327 /* 20 */
2328 case EM_PPC64: return "PowerPC64";
2329 case EM_S390_OLD:
2330 case EM_S390: return "IBM S/390";
2331 case EM_SPU: return "SPU";
2332 /* 30 */
2333 case EM_V800: return "Renesas V850 (using RH850 ABI)";
2334 case EM_FR20: return "Fujitsu FR20";
2335 case EM_RH32: return "TRW RH32";
2336 case EM_MCORE: return "MCORE";
2337 /* 40 */
2338 case EM_ARM: return "ARM";
2339 case EM_OLD_ALPHA: return "Digital Alpha (old)";
2340 case EM_SH: return "Renesas / SuperH SH";
2341 case EM_SPARCV9: return "Sparc v9";
2342 case EM_TRICORE: return "Siemens Tricore";
2343 case EM_ARC: return "ARC";
2344 case EM_H8_300: return "Renesas H8/300";
2345 case EM_H8_300H: return "Renesas H8/300H";
2346 case EM_H8S: return "Renesas H8S";
2347 case EM_H8_500: return "Renesas H8/500";
2348 /* 50 */
2349 case EM_IA_64: return "Intel IA-64";
2350 case EM_MIPS_X: return "Stanford MIPS-X";
2351 case EM_COLDFIRE: return "Motorola Coldfire";
2352 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
2353 case EM_MMA: return "Fujitsu Multimedia Accelerator";
2354 case EM_PCP: return "Siemens PCP";
2355 case EM_NCPU: return "Sony nCPU embedded RISC processor";
2356 case EM_NDR1: return "Denso NDR1 microprocesspr";
2357 case EM_STARCORE: return "Motorola Star*Core processor";
2358 case EM_ME16: return "Toyota ME16 processor";
2359 /* 60 */
2360 case EM_ST100: return "STMicroelectronics ST100 processor";
2361 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
2362 case EM_X86_64: return "Advanced Micro Devices X86-64";
2363 case EM_PDSP: return "Sony DSP processor";
2364 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
2365 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
2366 case EM_FX66: return "Siemens FX66 microcontroller";
2367 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2368 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
2369 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
2370 /* 70 */
2371 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
2372 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
2373 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
2374 case EM_SVX: return "Silicon Graphics SVx";
2375 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2376 case EM_VAX: return "Digital VAX";
2377 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
2378 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2379 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2380 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
2381 /* 80 */
2382 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
2383 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
2384 case EM_PRISM: return "Vitesse Prism";
2385 case EM_AVR_OLD:
2386 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
2387 case EM_CYGNUS_FR30:
2388 case EM_FR30: return "Fujitsu FR30";
2389 case EM_CYGNUS_D10V:
2390 case EM_D10V: return "d10v";
2391 case EM_CYGNUS_D30V:
2392 case EM_D30V: return "d30v";
2393 case EM_CYGNUS_V850:
2394 case EM_V850: return "Renesas V850";
2395 case EM_CYGNUS_M32R:
2396 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2397 case EM_CYGNUS_MN10300:
2398 case EM_MN10300: return "mn10300";
2399 /* 90 */
2400 case EM_CYGNUS_MN10200:
2401 case EM_MN10200: return "mn10200";
2402 case EM_PJ: return "picoJava";
2403 case EM_OR1K: return "OpenRISC 1000";
2404 case EM_ARC_COMPACT: return "ARCompact";
2405 case EM_XTENSA_OLD:
2406 case EM_XTENSA: return "Tensilica Xtensa Processor";
2407 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2408 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2409 case EM_NS32K: return "National Semiconductor 32000 series";
2410 case EM_TPC: return "Tenor Network TPC processor";
2411 case EM_SNP1K: return "Trebia SNP 1000 processor";
2412 /* 100 */
2413 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2414 case EM_IP2K_OLD:
2415 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
2416 case EM_MAX: return "MAX Processor";
2417 case EM_CR: return "National Semiconductor CompactRISC";
2418 case EM_F2MC16: return "Fujitsu F2MC16";
2419 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
2420 case EM_BLACKFIN: return "Analog Devices Blackfin";
2421 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2422 case EM_SEP: return "Sharp embedded microprocessor";
2423 case EM_ARCA: return "Arca RISC microprocessor";
2424 /* 110 */
2425 case EM_UNICORE: return "Unicore";
2426 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2427 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
2428 case EM_ALTERA_NIOS2: return "Altera Nios II";
2429 case EM_CRX: return "National Semiconductor CRX microprocessor";
2430 case EM_XGATE: return "Motorola XGATE embedded processor";
2431 case EM_C166:
2432 case EM_XC16X: return "Infineon Technologies xc16x";
2433 case EM_M16C: return "Renesas M16C series microprocessors";
2434 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2435 case EM_CE: return "Freescale Communication Engine RISC core";
2436 /* 120 */
2437 case EM_M32C: return "Renesas M32c";
2438 /* 130 */
2439 case EM_TSK3000: return "Altium TSK3000 core";
2440 case EM_RS08: return "Freescale RS08 embedded processor";
2441 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2442 case EM_SCORE: return "SUNPLUS S+Core";
2443 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2444 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2445 case EM_LATTICEMICO32: return "Lattice Mico32";
2446 case EM_SE_C17: return "Seiko Epson C17 family";
2447 /* 140 */
2448 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2449 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2450 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2451 case EM_TI_PRU: return "TI PRU I/O processor";
2452 /* 160 */
2453 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2454 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2455 case EM_R32C: return "Renesas R32C series microprocessors";
2456 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2457 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2458 case EM_8051: return "Intel 8051 and variants";
2459 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2460 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2461 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2462 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2463 /* 170 */
2464 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2465 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2466 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
2467 case EM_RX: return "Renesas RX";
2468 case EM_METAG: return "Imagination Technologies Meta processor architecture";
2469 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2470 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2471 case EM_CR16:
2472 case EM_MICROBLAZE:
2473 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
2474 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2475 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2476 /* 180 */
2477 case EM_L1OM: return "Intel L1OM";
2478 case EM_K1OM: return "Intel K1OM";
2479 case EM_INTEL182: return "Intel (reserved)";
2480 case EM_AARCH64: return "AArch64";
2481 case EM_ARM184: return "ARM (reserved)";
2482 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor";
2483 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2484 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2485 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
2486 /* 190 */
2487 case EM_CUDA: return "NVIDIA CUDA architecture";
2488 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
2489 case EM_CLOUDSHIELD: return "CloudShield architecture family";
2490 case EM_COREA_1ST: return "KIPO-KAIST Core-A 1st generation processor family";
2491 case EM_COREA_2ND: return "KIPO-KAIST Core-A 2nd generation processor family";
2492 case EM_ARC_COMPACT2: return "ARCv2";
2493 case EM_OPEN8: return "Open8 8-bit RISC soft processor core";
2494 case EM_RL78: return "Renesas RL78";
2495 case EM_VIDEOCORE5: return "Broadcom VideoCore V processor";
2496 case EM_78K0R: return "Renesas 78K0R";
2497 /* 200 */
2498 case EM_56800EX: return "Freescale 56800EX Digital Signal Controller (DSC)";
2499 case EM_BA1: return "Beyond BA1 CPU architecture";
2500 case EM_BA2: return "Beyond BA2 CPU architecture";
2501 case EM_XCORE: return "XMOS xCORE processor family";
2502 case EM_MCHP_PIC: return "Microchip 8-bit PIC(r) family";
2503 /* 210 */
2504 case EM_KM32: return "KM211 KM32 32-bit processor";
2505 case EM_KMX32: return "KM211 KMX32 32-bit processor";
2506 case EM_KMX16: return "KM211 KMX16 16-bit processor";
2507 case EM_KMX8: return "KM211 KMX8 8-bit processor";
2508 case EM_KVARC: return "KM211 KVARC processor";
2509 case EM_CDP: return "Paneve CDP architecture family";
2510 case EM_COGE: return "Cognitive Smart Memory Processor";
2511 case EM_COOL: return "Bluechip Systems CoolEngine";
2512 case EM_NORC: return "Nanoradio Optimized RISC";
2513 case EM_CSR_KALIMBA: return "CSR Kalimba architecture family";
2514 /* 220 */
2515 case EM_Z80: return "Zilog Z80";
2516 case EM_VISIUM: return "CDS VISIUMcore processor";
2517 case EM_FT32: return "FTDI Chip FT32";
2518 case EM_MOXIE: return "Moxie";
2519 case EM_AMDGPU: return "AMD GPU";
2520 case EM_RISCV: return "RISC-V";
2521 case EM_LANAI: return "Lanai 32-bit processor";
2522 case EM_BPF: return "Linux BPF";
2523 case EM_NFP: return "Netronome Flow Processor";
2524
2525 /* Large numbers... */
2526 case EM_MT: return "Morpho Techologies MT processor";
2527 case EM_ALPHA: return "Alpha";
2528 case EM_WEBASSEMBLY: return "Web Assembly";
2529 case EM_DLX: return "OpenDLX";
2530 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
2531 case EM_IQ2000: return "Vitesse IQ2000";
2532 case EM_M32C_OLD:
2533 case EM_NIOS32: return "Altera Nios";
2534 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
2535 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
2536 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2537 case EM_S12Z: return "Freescale S12Z";
2538 case EM_CSKY: return "C-SKY";
2539
2540 default:
2541 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2542 return buff;
2543 }
2544 }
2545
2546 static void
decode_ARC_machine_flags(unsigned e_flags,unsigned e_machine,char buf[])2547 decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
2548 {
2549 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2550 other compilers don't a specific architecture type in the e_flags, and
2551 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2552 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2553 architectures.
2554
2555 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2556 but also sets a specific architecture type in the e_flags field.
2557
2558 However, when decoding the flags we don't worry if we see an
2559 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2560 ARCEM architecture type. */
2561
2562 switch (e_flags & EF_ARC_MACH_MSK)
2563 {
2564 /* We only expect these to occur for EM_ARC_COMPACT2. */
2565 case EF_ARC_CPU_ARCV2EM:
2566 strcat (buf, ", ARC EM");
2567 break;
2568 case EF_ARC_CPU_ARCV2HS:
2569 strcat (buf, ", ARC HS");
2570 break;
2571
2572 /* We only expect these to occur for EM_ARC_COMPACT. */
2573 case E_ARC_MACH_ARC600:
2574 strcat (buf, ", ARC600");
2575 break;
2576 case E_ARC_MACH_ARC601:
2577 strcat (buf, ", ARC601");
2578 break;
2579 case E_ARC_MACH_ARC700:
2580 strcat (buf, ", ARC700");
2581 break;
2582
2583 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2584 new ELF with new architecture being read by an old version of
2585 readelf, or (c) An ELF built with non-GNU compiler that does not
2586 set the architecture in the e_flags. */
2587 default:
2588 if (e_machine == EM_ARC_COMPACT)
2589 strcat (buf, ", Unknown ARCompact");
2590 else
2591 strcat (buf, ", Unknown ARC");
2592 break;
2593 }
2594
2595 switch (e_flags & EF_ARC_OSABI_MSK)
2596 {
2597 case E_ARC_OSABI_ORIG:
2598 strcat (buf, ", (ABI:legacy)");
2599 break;
2600 case E_ARC_OSABI_V2:
2601 strcat (buf, ", (ABI:v2)");
2602 break;
2603 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2604 case E_ARC_OSABI_V3:
2605 strcat (buf, ", v3 no-legacy-syscalls ABI");
2606 break;
2607 case E_ARC_OSABI_V4:
2608 strcat (buf, ", v4 ABI");
2609 break;
2610 default:
2611 strcat (buf, ", unrecognised ARC OSABI flag");
2612 break;
2613 }
2614 }
2615
2616 static void
decode_ARM_machine_flags(unsigned e_flags,char buf[])2617 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2618 {
2619 unsigned eabi;
2620 bfd_boolean unknown = FALSE;
2621
2622 eabi = EF_ARM_EABI_VERSION (e_flags);
2623 e_flags &= ~ EF_ARM_EABIMASK;
2624
2625 /* Handle "generic" ARM flags. */
2626 if (e_flags & EF_ARM_RELEXEC)
2627 {
2628 strcat (buf, ", relocatable executable");
2629 e_flags &= ~ EF_ARM_RELEXEC;
2630 }
2631
2632 if (e_flags & EF_ARM_PIC)
2633 {
2634 strcat (buf, ", position independent");
2635 e_flags &= ~ EF_ARM_PIC;
2636 }
2637
2638 /* Now handle EABI specific flags. */
2639 switch (eabi)
2640 {
2641 default:
2642 strcat (buf, ", <unrecognized EABI>");
2643 if (e_flags)
2644 unknown = TRUE;
2645 break;
2646
2647 case EF_ARM_EABI_VER1:
2648 strcat (buf, ", Version1 EABI");
2649 while (e_flags)
2650 {
2651 unsigned flag;
2652
2653 /* Process flags one bit at a time. */
2654 flag = e_flags & - e_flags;
2655 e_flags &= ~ flag;
2656
2657 switch (flag)
2658 {
2659 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2660 strcat (buf, ", sorted symbol tables");
2661 break;
2662
2663 default:
2664 unknown = TRUE;
2665 break;
2666 }
2667 }
2668 break;
2669
2670 case EF_ARM_EABI_VER2:
2671 strcat (buf, ", Version2 EABI");
2672 while (e_flags)
2673 {
2674 unsigned flag;
2675
2676 /* Process flags one bit at a time. */
2677 flag = e_flags & - e_flags;
2678 e_flags &= ~ flag;
2679
2680 switch (flag)
2681 {
2682 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2683 strcat (buf, ", sorted symbol tables");
2684 break;
2685
2686 case EF_ARM_DYNSYMSUSESEGIDX:
2687 strcat (buf, ", dynamic symbols use segment index");
2688 break;
2689
2690 case EF_ARM_MAPSYMSFIRST:
2691 strcat (buf, ", mapping symbols precede others");
2692 break;
2693
2694 default:
2695 unknown = TRUE;
2696 break;
2697 }
2698 }
2699 break;
2700
2701 case EF_ARM_EABI_VER3:
2702 strcat (buf, ", Version3 EABI");
2703 break;
2704
2705 case EF_ARM_EABI_VER4:
2706 strcat (buf, ", Version4 EABI");
2707 while (e_flags)
2708 {
2709 unsigned flag;
2710
2711 /* Process flags one bit at a time. */
2712 flag = e_flags & - e_flags;
2713 e_flags &= ~ flag;
2714
2715 switch (flag)
2716 {
2717 case EF_ARM_BE8:
2718 strcat (buf, ", BE8");
2719 break;
2720
2721 case EF_ARM_LE8:
2722 strcat (buf, ", LE8");
2723 break;
2724
2725 default:
2726 unknown = TRUE;
2727 break;
2728 }
2729 }
2730 break;
2731
2732 case EF_ARM_EABI_VER5:
2733 strcat (buf, ", Version5 EABI");
2734 while (e_flags)
2735 {
2736 unsigned flag;
2737
2738 /* Process flags one bit at a time. */
2739 flag = e_flags & - e_flags;
2740 e_flags &= ~ flag;
2741
2742 switch (flag)
2743 {
2744 case EF_ARM_BE8:
2745 strcat (buf, ", BE8");
2746 break;
2747
2748 case EF_ARM_LE8:
2749 strcat (buf, ", LE8");
2750 break;
2751
2752 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2753 strcat (buf, ", soft-float ABI");
2754 break;
2755
2756 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2757 strcat (buf, ", hard-float ABI");
2758 break;
2759
2760 default:
2761 unknown = TRUE;
2762 break;
2763 }
2764 }
2765 break;
2766
2767 case EF_ARM_EABI_UNKNOWN:
2768 strcat (buf, ", GNU EABI");
2769 while (e_flags)
2770 {
2771 unsigned flag;
2772
2773 /* Process flags one bit at a time. */
2774 flag = e_flags & - e_flags;
2775 e_flags &= ~ flag;
2776
2777 switch (flag)
2778 {
2779 case EF_ARM_INTERWORK:
2780 strcat (buf, ", interworking enabled");
2781 break;
2782
2783 case EF_ARM_APCS_26:
2784 strcat (buf, ", uses APCS/26");
2785 break;
2786
2787 case EF_ARM_APCS_FLOAT:
2788 strcat (buf, ", uses APCS/float");
2789 break;
2790
2791 case EF_ARM_PIC:
2792 strcat (buf, ", position independent");
2793 break;
2794
2795 case EF_ARM_ALIGN8:
2796 strcat (buf, ", 8 bit structure alignment");
2797 break;
2798
2799 case EF_ARM_NEW_ABI:
2800 strcat (buf, ", uses new ABI");
2801 break;
2802
2803 case EF_ARM_OLD_ABI:
2804 strcat (buf, ", uses old ABI");
2805 break;
2806
2807 case EF_ARM_SOFT_FLOAT:
2808 strcat (buf, ", software FP");
2809 break;
2810
2811 case EF_ARM_VFP_FLOAT:
2812 strcat (buf, ", VFP");
2813 break;
2814
2815 case EF_ARM_MAVERICK_FLOAT:
2816 strcat (buf, ", Maverick FP");
2817 break;
2818
2819 default:
2820 unknown = TRUE;
2821 break;
2822 }
2823 }
2824 }
2825
2826 if (unknown)
2827 strcat (buf,_(", <unknown>"));
2828 }
2829
2830 static void
decode_AVR_machine_flags(unsigned e_flags,char buf[],size_t size)2831 decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2832 {
2833 --size; /* Leave space for null terminator. */
2834
2835 switch (e_flags & EF_AVR_MACH)
2836 {
2837 case E_AVR_MACH_AVR1:
2838 strncat (buf, ", avr:1", size);
2839 break;
2840 case E_AVR_MACH_AVR2:
2841 strncat (buf, ", avr:2", size);
2842 break;
2843 case E_AVR_MACH_AVR25:
2844 strncat (buf, ", avr:25", size);
2845 break;
2846 case E_AVR_MACH_AVR3:
2847 strncat (buf, ", avr:3", size);
2848 break;
2849 case E_AVR_MACH_AVR31:
2850 strncat (buf, ", avr:31", size);
2851 break;
2852 case E_AVR_MACH_AVR35:
2853 strncat (buf, ", avr:35", size);
2854 break;
2855 case E_AVR_MACH_AVR4:
2856 strncat (buf, ", avr:4", size);
2857 break;
2858 case E_AVR_MACH_AVR5:
2859 strncat (buf, ", avr:5", size);
2860 break;
2861 case E_AVR_MACH_AVR51:
2862 strncat (buf, ", avr:51", size);
2863 break;
2864 case E_AVR_MACH_AVR6:
2865 strncat (buf, ", avr:6", size);
2866 break;
2867 case E_AVR_MACH_AVRTINY:
2868 strncat (buf, ", avr:100", size);
2869 break;
2870 case E_AVR_MACH_XMEGA1:
2871 strncat (buf, ", avr:101", size);
2872 break;
2873 case E_AVR_MACH_XMEGA2:
2874 strncat (buf, ", avr:102", size);
2875 break;
2876 case E_AVR_MACH_XMEGA3:
2877 strncat (buf, ", avr:103", size);
2878 break;
2879 case E_AVR_MACH_XMEGA4:
2880 strncat (buf, ", avr:104", size);
2881 break;
2882 case E_AVR_MACH_XMEGA5:
2883 strncat (buf, ", avr:105", size);
2884 break;
2885 case E_AVR_MACH_XMEGA6:
2886 strncat (buf, ", avr:106", size);
2887 break;
2888 case E_AVR_MACH_XMEGA7:
2889 strncat (buf, ", avr:107", size);
2890 break;
2891 default:
2892 strncat (buf, ", avr:<unknown>", size);
2893 break;
2894 }
2895
2896 size -= strlen (buf);
2897 if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2898 strncat (buf, ", link-relax", size);
2899 }
2900
2901 static void
decode_NDS32_machine_flags(unsigned e_flags,char buf[],size_t size)2902 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2903 {
2904 unsigned abi;
2905 unsigned arch;
2906 unsigned config;
2907 unsigned version;
2908 bfd_boolean has_fpu = FALSE;
2909 unsigned int r = 0;
2910
2911 static const char *ABI_STRINGS[] =
2912 {
2913 "ABI v0", /* use r5 as return register; only used in N1213HC */
2914 "ABI v1", /* use r0 as return register */
2915 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2916 "ABI v2fp", /* for FPU */
2917 "AABI",
2918 "ABI2 FP+"
2919 };
2920 static const char *VER_STRINGS[] =
2921 {
2922 "Andes ELF V1.3 or older",
2923 "Andes ELF V1.3.1",
2924 "Andes ELF V1.4"
2925 };
2926 static const char *ARCH_STRINGS[] =
2927 {
2928 "",
2929 "Andes Star v1.0",
2930 "Andes Star v2.0",
2931 "Andes Star v3.0",
2932 "Andes Star v3.0m"
2933 };
2934
2935 abi = EF_NDS_ABI & e_flags;
2936 arch = EF_NDS_ARCH & e_flags;
2937 config = EF_NDS_INST & e_flags;
2938 version = EF_NDS32_ELF_VERSION & e_flags;
2939
2940 memset (buf, 0, size);
2941
2942 switch (abi)
2943 {
2944 case E_NDS_ABI_V0:
2945 case E_NDS_ABI_V1:
2946 case E_NDS_ABI_V2:
2947 case E_NDS_ABI_V2FP:
2948 case E_NDS_ABI_AABI:
2949 case E_NDS_ABI_V2FP_PLUS:
2950 /* In case there are holes in the array. */
2951 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2952 break;
2953
2954 default:
2955 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2956 break;
2957 }
2958
2959 switch (version)
2960 {
2961 case E_NDS32_ELF_VER_1_2:
2962 case E_NDS32_ELF_VER_1_3:
2963 case E_NDS32_ELF_VER_1_4:
2964 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2965 break;
2966
2967 default:
2968 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2969 break;
2970 }
2971
2972 if (E_NDS_ABI_V0 == abi)
2973 {
2974 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2975 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2976 if (arch == E_NDS_ARCH_STAR_V1_0)
2977 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2978 return;
2979 }
2980
2981 switch (arch)
2982 {
2983 case E_NDS_ARCH_STAR_V1_0:
2984 case E_NDS_ARCH_STAR_V2_0:
2985 case E_NDS_ARCH_STAR_V3_0:
2986 case E_NDS_ARCH_STAR_V3_M:
2987 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2988 break;
2989
2990 default:
2991 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2992 /* ARCH version determines how the e_flags are interpreted.
2993 If it is unknown, we cannot proceed. */
2994 return;
2995 }
2996
2997 /* Newer ABI; Now handle architecture specific flags. */
2998 if (arch == E_NDS_ARCH_STAR_V1_0)
2999 {
3000 if (config & E_NDS32_HAS_MFUSR_PC_INST)
3001 r += snprintf (buf + r, size -r, ", MFUSR_PC");
3002
3003 if (!(config & E_NDS32_HAS_NO_MAC_INST))
3004 r += snprintf (buf + r, size -r, ", MAC");
3005
3006 if (config & E_NDS32_HAS_DIV_INST)
3007 r += snprintf (buf + r, size -r, ", DIV");
3008
3009 if (config & E_NDS32_HAS_16BIT_INST)
3010 r += snprintf (buf + r, size -r, ", 16b");
3011 }
3012 else
3013 {
3014 if (config & E_NDS32_HAS_MFUSR_PC_INST)
3015 {
3016 if (version <= E_NDS32_ELF_VER_1_3)
3017 r += snprintf (buf + r, size -r, ", [B8]");
3018 else
3019 r += snprintf (buf + r, size -r, ", EX9");
3020 }
3021
3022 if (config & E_NDS32_HAS_MAC_DX_INST)
3023 r += snprintf (buf + r, size -r, ", MAC_DX");
3024
3025 if (config & E_NDS32_HAS_DIV_DX_INST)
3026 r += snprintf (buf + r, size -r, ", DIV_DX");
3027
3028 if (config & E_NDS32_HAS_16BIT_INST)
3029 {
3030 if (version <= E_NDS32_ELF_VER_1_3)
3031 r += snprintf (buf + r, size -r, ", 16b");
3032 else
3033 r += snprintf (buf + r, size -r, ", IFC");
3034 }
3035 }
3036
3037 if (config & E_NDS32_HAS_EXT_INST)
3038 r += snprintf (buf + r, size -r, ", PERF1");
3039
3040 if (config & E_NDS32_HAS_EXT2_INST)
3041 r += snprintf (buf + r, size -r, ", PERF2");
3042
3043 if (config & E_NDS32_HAS_FPU_INST)
3044 {
3045 has_fpu = TRUE;
3046 r += snprintf (buf + r, size -r, ", FPU_SP");
3047 }
3048
3049 if (config & E_NDS32_HAS_FPU_DP_INST)
3050 {
3051 has_fpu = TRUE;
3052 r += snprintf (buf + r, size -r, ", FPU_DP");
3053 }
3054
3055 if (config & E_NDS32_HAS_FPU_MAC_INST)
3056 {
3057 has_fpu = TRUE;
3058 r += snprintf (buf + r, size -r, ", FPU_MAC");
3059 }
3060
3061 if (has_fpu)
3062 {
3063 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
3064 {
3065 case E_NDS32_FPU_REG_8SP_4DP:
3066 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
3067 break;
3068 case E_NDS32_FPU_REG_16SP_8DP:
3069 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
3070 break;
3071 case E_NDS32_FPU_REG_32SP_16DP:
3072 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
3073 break;
3074 case E_NDS32_FPU_REG_32SP_32DP:
3075 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
3076 break;
3077 }
3078 }
3079
3080 if (config & E_NDS32_HAS_AUDIO_INST)
3081 r += snprintf (buf + r, size -r, ", AUDIO");
3082
3083 if (config & E_NDS32_HAS_STRING_INST)
3084 r += snprintf (buf + r, size -r, ", STR");
3085
3086 if (config & E_NDS32_HAS_REDUCED_REGS)
3087 r += snprintf (buf + r, size -r, ", 16REG");
3088
3089 if (config & E_NDS32_HAS_VIDEO_INST)
3090 {
3091 if (version <= E_NDS32_ELF_VER_1_3)
3092 r += snprintf (buf + r, size -r, ", VIDEO");
3093 else
3094 r += snprintf (buf + r, size -r, ", SATURATION");
3095 }
3096
3097 if (config & E_NDS32_HAS_ENCRIPT_INST)
3098 r += snprintf (buf + r, size -r, ", ENCRP");
3099
3100 if (config & E_NDS32_HAS_L2C_INST)
3101 r += snprintf (buf + r, size -r, ", L2C");
3102 }
3103
3104 static char *
get_machine_flags(Filedata * filedata,unsigned e_flags,unsigned e_machine)3105 get_machine_flags (Filedata * filedata, unsigned e_flags, unsigned e_machine)
3106 {
3107 static char buf[1024];
3108
3109 buf[0] = '\0';
3110
3111 if (e_flags)
3112 {
3113 switch (e_machine)
3114 {
3115 default:
3116 break;
3117
3118 case EM_ARC_COMPACT2:
3119 case EM_ARC_COMPACT:
3120 decode_ARC_machine_flags (e_flags, e_machine, buf);
3121 break;
3122
3123 case EM_ARM:
3124 decode_ARM_machine_flags (e_flags, buf);
3125 break;
3126
3127 case EM_AVR:
3128 decode_AVR_machine_flags (e_flags, buf, sizeof buf);
3129 break;
3130
3131 case EM_BLACKFIN:
3132 if (e_flags & EF_BFIN_PIC)
3133 strcat (buf, ", PIC");
3134
3135 if (e_flags & EF_BFIN_FDPIC)
3136 strcat (buf, ", FDPIC");
3137
3138 if (e_flags & EF_BFIN_CODE_IN_L1)
3139 strcat (buf, ", code in L1");
3140
3141 if (e_flags & EF_BFIN_DATA_IN_L1)
3142 strcat (buf, ", data in L1");
3143
3144 break;
3145
3146 case EM_CYGNUS_FRV:
3147 switch (e_flags & EF_FRV_CPU_MASK)
3148 {
3149 case EF_FRV_CPU_GENERIC:
3150 break;
3151
3152 default:
3153 strcat (buf, ", fr???");
3154 break;
3155
3156 case EF_FRV_CPU_FR300:
3157 strcat (buf, ", fr300");
3158 break;
3159
3160 case EF_FRV_CPU_FR400:
3161 strcat (buf, ", fr400");
3162 break;
3163 case EF_FRV_CPU_FR405:
3164 strcat (buf, ", fr405");
3165 break;
3166
3167 case EF_FRV_CPU_FR450:
3168 strcat (buf, ", fr450");
3169 break;
3170
3171 case EF_FRV_CPU_FR500:
3172 strcat (buf, ", fr500");
3173 break;
3174 case EF_FRV_CPU_FR550:
3175 strcat (buf, ", fr550");
3176 break;
3177
3178 case EF_FRV_CPU_SIMPLE:
3179 strcat (buf, ", simple");
3180 break;
3181 case EF_FRV_CPU_TOMCAT:
3182 strcat (buf, ", tomcat");
3183 break;
3184 }
3185 break;
3186
3187 case EM_68K:
3188 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
3189 strcat (buf, ", m68000");
3190 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3191 strcat (buf, ", cpu32");
3192 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
3193 strcat (buf, ", fido_a");
3194 else
3195 {
3196 char const * isa = _("unknown");
3197 char const * mac = _("unknown mac");
3198 char const * additional = NULL;
3199
3200 switch (e_flags & EF_M68K_CF_ISA_MASK)
3201 {
3202 case EF_M68K_CF_ISA_A_NODIV:
3203 isa = "A";
3204 additional = ", nodiv";
3205 break;
3206 case EF_M68K_CF_ISA_A:
3207 isa = "A";
3208 break;
3209 case EF_M68K_CF_ISA_A_PLUS:
3210 isa = "A+";
3211 break;
3212 case EF_M68K_CF_ISA_B_NOUSP:
3213 isa = "B";
3214 additional = ", nousp";
3215 break;
3216 case EF_M68K_CF_ISA_B:
3217 isa = "B";
3218 break;
3219 case EF_M68K_CF_ISA_C:
3220 isa = "C";
3221 break;
3222 case EF_M68K_CF_ISA_C_NODIV:
3223 isa = "C";
3224 additional = ", nodiv";
3225 break;
3226 }
3227 strcat (buf, ", cf, isa ");
3228 strcat (buf, isa);
3229 if (additional)
3230 strcat (buf, additional);
3231 if (e_flags & EF_M68K_CF_FLOAT)
3232 strcat (buf, ", float");
3233 switch (e_flags & EF_M68K_CF_MAC_MASK)
3234 {
3235 case 0:
3236 mac = NULL;
3237 break;
3238 case EF_M68K_CF_MAC:
3239 mac = "mac";
3240 break;
3241 case EF_M68K_CF_EMAC:
3242 mac = "emac";
3243 break;
3244 case EF_M68K_CF_EMAC_B:
3245 mac = "emac_b";
3246 break;
3247 }
3248 if (mac)
3249 {
3250 strcat (buf, ", ");
3251 strcat (buf, mac);
3252 }
3253 }
3254 break;
3255
3256 case EM_CYGNUS_MEP:
3257 switch (e_flags & EF_MEP_CPU_MASK)
3258 {
3259 case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
3260 case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
3261 case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
3262 case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
3263 case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
3264 case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
3265 default: strcat (buf, _(", <unknown MeP cpu type>")); break;
3266 }
3267
3268 switch (e_flags & EF_MEP_COP_MASK)
3269 {
3270 case EF_MEP_COP_NONE: break;
3271 case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
3272 case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
3273 case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
3274 case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
3275 default: strcat (buf, _("<unknown MeP copro type>")); break;
3276 }
3277
3278 if (e_flags & EF_MEP_LIBRARY)
3279 strcat (buf, ", Built for Library");
3280
3281 if (e_flags & EF_MEP_INDEX_MASK)
3282 sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3283 e_flags & EF_MEP_INDEX_MASK);
3284
3285 if (e_flags & ~ EF_MEP_ALL_FLAGS)
3286 sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3287 e_flags & ~ EF_MEP_ALL_FLAGS);
3288 break;
3289
3290 case EM_PPC:
3291 if (e_flags & EF_PPC_EMB)
3292 strcat (buf, ", emb");
3293
3294 if (e_flags & EF_PPC_RELOCATABLE)
3295 strcat (buf, _(", relocatable"));
3296
3297 if (e_flags & EF_PPC_RELOCATABLE_LIB)
3298 strcat (buf, _(", relocatable-lib"));
3299 break;
3300
3301 case EM_PPC64:
3302 if (e_flags & EF_PPC64_ABI)
3303 {
3304 char abi[] = ", abiv0";
3305
3306 abi[6] += e_flags & EF_PPC64_ABI;
3307 strcat (buf, abi);
3308 }
3309 break;
3310
3311 case EM_V800:
3312 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3313 strcat (buf, ", RH850 ABI");
3314
3315 if (e_flags & EF_V800_850E3)
3316 strcat (buf, ", V3 architecture");
3317
3318 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3319 strcat (buf, ", FPU not used");
3320
3321 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3322 strcat (buf, ", regmode: COMMON");
3323
3324 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3325 strcat (buf, ", r4 not used");
3326
3327 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3328 strcat (buf, ", r30 not used");
3329
3330 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3331 strcat (buf, ", r5 not used");
3332
3333 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3334 strcat (buf, ", r2 not used");
3335
3336 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3337 {
3338 switch (e_flags & - e_flags)
3339 {
3340 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3341 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
3342 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3343 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
3344 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3345 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3346 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3347 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3348 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3349 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3350 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3351 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3352 default: break;
3353 }
3354 }
3355 break;
3356
3357 case EM_V850:
3358 case EM_CYGNUS_V850:
3359 switch (e_flags & EF_V850_ARCH)
3360 {
3361 case E_V850E3V5_ARCH:
3362 strcat (buf, ", v850e3v5");
3363 break;
3364 case E_V850E2V3_ARCH:
3365 strcat (buf, ", v850e2v3");
3366 break;
3367 case E_V850E2_ARCH:
3368 strcat (buf, ", v850e2");
3369 break;
3370 case E_V850E1_ARCH:
3371 strcat (buf, ", v850e1");
3372 break;
3373 case E_V850E_ARCH:
3374 strcat (buf, ", v850e");
3375 break;
3376 case E_V850_ARCH:
3377 strcat (buf, ", v850");
3378 break;
3379 default:
3380 strcat (buf, _(", unknown v850 architecture variant"));
3381 break;
3382 }
3383 break;
3384
3385 case EM_M32R:
3386 case EM_CYGNUS_M32R:
3387 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3388 strcat (buf, ", m32r");
3389 break;
3390
3391 case EM_MIPS:
3392 case EM_MIPS_RS3_LE:
3393 if (e_flags & EF_MIPS_NOREORDER)
3394 strcat (buf, ", noreorder");
3395
3396 if (e_flags & EF_MIPS_PIC)
3397 strcat (buf, ", pic");
3398
3399 if (e_flags & EF_MIPS_CPIC)
3400 strcat (buf, ", cpic");
3401
3402 if (e_flags & EF_MIPS_UCODE)
3403 strcat (buf, ", ugen_reserved");
3404
3405 if (e_flags & EF_MIPS_ABI2)
3406 strcat (buf, ", abi2");
3407
3408 if (e_flags & EF_MIPS_OPTIONS_FIRST)
3409 strcat (buf, ", odk first");
3410
3411 if (e_flags & EF_MIPS_32BITMODE)
3412 strcat (buf, ", 32bitmode");
3413
3414 if (e_flags & EF_MIPS_NAN2008)
3415 strcat (buf, ", nan2008");
3416
3417 if (e_flags & EF_MIPS_FP64)
3418 strcat (buf, ", fp64");
3419
3420 switch ((e_flags & EF_MIPS_MACH))
3421 {
3422 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3423 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3424 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3425 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3426 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3427 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3428 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3429 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3430 case E_MIPS_MACH_5900: strcat (buf, ", 5900"); break;
3431 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
3432 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3433 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3434 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3435 case E_MIPS_MACH_GS464: strcat (buf, ", gs464"); break;
3436 case E_MIPS_MACH_GS464E: strcat (buf, ", gs464e"); break;
3437 case E_MIPS_MACH_GS264E: strcat (buf, ", gs264e"); break;
3438 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3439 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3440 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3441 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
3442 case E_MIPS_MACH_IAMR2: strcat (buf, ", interaptiv-mr2"); break;
3443 case 0:
3444 /* We simply ignore the field in this case to avoid confusion:
3445 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3446 extension. */
3447 break;
3448 default: strcat (buf, _(", unknown CPU")); break;
3449 }
3450
3451 switch ((e_flags & EF_MIPS_ABI))
3452 {
3453 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3454 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3455 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3456 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3457 case 0:
3458 /* We simply ignore the field in this case to avoid confusion:
3459 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3460 This means it is likely to be an o32 file, but not for
3461 sure. */
3462 break;
3463 default: strcat (buf, _(", unknown ABI")); break;
3464 }
3465
3466 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3467 strcat (buf, ", mdmx");
3468
3469 if (e_flags & EF_MIPS_ARCH_ASE_M16)
3470 strcat (buf, ", mips16");
3471
3472 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3473 strcat (buf, ", micromips");
3474
3475 switch ((e_flags & EF_MIPS_ARCH))
3476 {
3477 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3478 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3479 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3480 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3481 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3482 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3483 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3484 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3485 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3486 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3487 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3488 default: strcat (buf, _(", unknown ISA")); break;
3489 }
3490 break;
3491
3492 case EM_NDS32:
3493 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3494 break;
3495
3496 case EM_NFP:
3497 switch (EF_NFP_MACH (e_flags))
3498 {
3499 case E_NFP_MACH_3200:
3500 strcat (buf, ", NFP-32xx");
3501 break;
3502 case E_NFP_MACH_6000:
3503 strcat (buf, ", NFP-6xxx");
3504 break;
3505 }
3506 break;
3507
3508 case EM_RISCV:
3509 if (e_flags & EF_RISCV_RVC)
3510 strcat (buf, ", RVC");
3511
3512 if (e_flags & EF_RISCV_RVE)
3513 strcat (buf, ", RVE");
3514
3515 switch (e_flags & EF_RISCV_FLOAT_ABI)
3516 {
3517 case EF_RISCV_FLOAT_ABI_SOFT:
3518 strcat (buf, ", soft-float ABI");
3519 break;
3520
3521 case EF_RISCV_FLOAT_ABI_SINGLE:
3522 strcat (buf, ", single-float ABI");
3523 break;
3524
3525 case EF_RISCV_FLOAT_ABI_DOUBLE:
3526 strcat (buf, ", double-float ABI");
3527 break;
3528
3529 case EF_RISCV_FLOAT_ABI_QUAD:
3530 strcat (buf, ", quad-float ABI");
3531 break;
3532 }
3533 break;
3534
3535 case EM_SH:
3536 switch ((e_flags & EF_SH_MACH_MASK))
3537 {
3538 case EF_SH1: strcat (buf, ", sh1"); break;
3539 case EF_SH2: strcat (buf, ", sh2"); break;
3540 case EF_SH3: strcat (buf, ", sh3"); break;
3541 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3542 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3543 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3544 case EF_SH3E: strcat (buf, ", sh3e"); break;
3545 case EF_SH4: strcat (buf, ", sh4"); break;
3546 case EF_SH5: strcat (buf, ", sh5"); break;
3547 case EF_SH2E: strcat (buf, ", sh2e"); break;
3548 case EF_SH4A: strcat (buf, ", sh4a"); break;
3549 case EF_SH2A: strcat (buf, ", sh2a"); break;
3550 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3551 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3552 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3553 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3554 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3555 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3556 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3557 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3558 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3559 default: strcat (buf, _(", unknown ISA")); break;
3560 }
3561
3562 if (e_flags & EF_SH_PIC)
3563 strcat (buf, ", pic");
3564
3565 if (e_flags & EF_SH_FDPIC)
3566 strcat (buf, ", fdpic");
3567 break;
3568
3569 case EM_OR1K:
3570 if (e_flags & EF_OR1K_NODELAY)
3571 strcat (buf, ", no delay");
3572 break;
3573
3574 case EM_SPARCV9:
3575 if (e_flags & EF_SPARC_32PLUS)
3576 strcat (buf, ", v8+");
3577
3578 if (e_flags & EF_SPARC_SUN_US1)
3579 strcat (buf, ", ultrasparcI");
3580
3581 if (e_flags & EF_SPARC_SUN_US3)
3582 strcat (buf, ", ultrasparcIII");
3583
3584 if (e_flags & EF_SPARC_HAL_R1)
3585 strcat (buf, ", halr1");
3586
3587 if (e_flags & EF_SPARC_LEDATA)
3588 strcat (buf, ", ledata");
3589
3590 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3591 strcat (buf, ", tso");
3592
3593 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3594 strcat (buf, ", pso");
3595
3596 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3597 strcat (buf, ", rmo");
3598 break;
3599
3600 case EM_PARISC:
3601 switch (e_flags & EF_PARISC_ARCH)
3602 {
3603 case EFA_PARISC_1_0:
3604 strcpy (buf, ", PA-RISC 1.0");
3605 break;
3606 case EFA_PARISC_1_1:
3607 strcpy (buf, ", PA-RISC 1.1");
3608 break;
3609 case EFA_PARISC_2_0:
3610 strcpy (buf, ", PA-RISC 2.0");
3611 break;
3612 default:
3613 break;
3614 }
3615 if (e_flags & EF_PARISC_TRAPNIL)
3616 strcat (buf, ", trapnil");
3617 if (e_flags & EF_PARISC_EXT)
3618 strcat (buf, ", ext");
3619 if (e_flags & EF_PARISC_LSB)
3620 strcat (buf, ", lsb");
3621 if (e_flags & EF_PARISC_WIDE)
3622 strcat (buf, ", wide");
3623 if (e_flags & EF_PARISC_NO_KABP)
3624 strcat (buf, ", no kabp");
3625 if (e_flags & EF_PARISC_LAZYSWAP)
3626 strcat (buf, ", lazyswap");
3627 break;
3628
3629 case EM_PJ:
3630 case EM_PJ_OLD:
3631 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3632 strcat (buf, ", new calling convention");
3633
3634 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3635 strcat (buf, ", gnu calling convention");
3636 break;
3637
3638 case EM_IA_64:
3639 if ((e_flags & EF_IA_64_ABI64))
3640 strcat (buf, ", 64-bit");
3641 else
3642 strcat (buf, ", 32-bit");
3643 if ((e_flags & EF_IA_64_REDUCEDFP))
3644 strcat (buf, ", reduced fp model");
3645 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3646 strcat (buf, ", no function descriptors, constant gp");
3647 else if ((e_flags & EF_IA_64_CONS_GP))
3648 strcat (buf, ", constant gp");
3649 if ((e_flags & EF_IA_64_ABSOLUTE))
3650 strcat (buf, ", absolute");
3651 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3652 {
3653 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3654 strcat (buf, ", vms_linkages");
3655 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3656 {
3657 case EF_IA_64_VMS_COMCOD_SUCCESS:
3658 break;
3659 case EF_IA_64_VMS_COMCOD_WARNING:
3660 strcat (buf, ", warning");
3661 break;
3662 case EF_IA_64_VMS_COMCOD_ERROR:
3663 strcat (buf, ", error");
3664 break;
3665 case EF_IA_64_VMS_COMCOD_ABORT:
3666 strcat (buf, ", abort");
3667 break;
3668 default:
3669 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3670 e_flags & EF_IA_64_VMS_COMCOD);
3671 strcat (buf, ", <unknown>");
3672 }
3673 }
3674 break;
3675
3676 case EM_VAX:
3677 if ((e_flags & EF_VAX_NONPIC))
3678 strcat (buf, ", non-PIC");
3679 if ((e_flags & EF_VAX_DFLOAT))
3680 strcat (buf, ", D-Float");
3681 if ((e_flags & EF_VAX_GFLOAT))
3682 strcat (buf, ", G-Float");
3683 break;
3684
3685 case EM_VISIUM:
3686 if (e_flags & EF_VISIUM_ARCH_MCM)
3687 strcat (buf, ", mcm");
3688 else if (e_flags & EF_VISIUM_ARCH_MCM24)
3689 strcat (buf, ", mcm24");
3690 if (e_flags & EF_VISIUM_ARCH_GR6)
3691 strcat (buf, ", gr6");
3692 break;
3693
3694 case EM_RL78:
3695 switch (e_flags & E_FLAG_RL78_CPU_MASK)
3696 {
3697 case E_FLAG_RL78_ANY_CPU: break;
3698 case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3699 case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3700 case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3701 }
3702 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3703 strcat (buf, ", 64-bit doubles");
3704 break;
3705
3706 case EM_RX:
3707 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3708 strcat (buf, ", 64-bit doubles");
3709 if (e_flags & E_FLAG_RX_DSP)
3710 strcat (buf, ", dsp");
3711 if (e_flags & E_FLAG_RX_PID)
3712 strcat (buf, ", pid");
3713 if (e_flags & E_FLAG_RX_ABI)
3714 strcat (buf, ", RX ABI");
3715 if (e_flags & E_FLAG_RX_SINSNS_SET)
3716 strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3717 ? ", uses String instructions" : ", bans String instructions");
3718 if (e_flags & E_FLAG_RX_V2)
3719 strcat (buf, ", V2");
3720 if (e_flags & E_FLAG_RX_V3)
3721 strcat (buf, ", V3");
3722 break;
3723
3724 case EM_S390:
3725 if (e_flags & EF_S390_HIGH_GPRS)
3726 strcat (buf, ", highgprs");
3727 break;
3728
3729 case EM_TI_C6000:
3730 if ((e_flags & EF_C6000_REL))
3731 strcat (buf, ", relocatable module");
3732 break;
3733
3734 case EM_MSP430:
3735 strcat (buf, _(": architecture variant: "));
3736 switch (e_flags & EF_MSP430_MACH)
3737 {
3738 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3739 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3740 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3741 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3742 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3743 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3744 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3745 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3746 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3747 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3748 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3749 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3750 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3751 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3752 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3753 default:
3754 strcat (buf, _(": unknown")); break;
3755 }
3756
3757 if (e_flags & ~ EF_MSP430_MACH)
3758 strcat (buf, _(": unknown extra flag bits also present"));
3759 break;
3760
3761 case EM_Z80:
3762 switch (e_flags & EF_Z80_MACH_MSK)
3763 {
3764 case EF_Z80_MACH_Z80: strcat (buf, ", Z80"); break;
3765 case EF_Z80_MACH_Z180: strcat (buf, ", Z180"); break;
3766 case EF_Z80_MACH_R800: strcat (buf, ", R800"); break;
3767 case EF_Z80_MACH_EZ80_Z80: strcat (buf, ", EZ80"); break;
3768 case EF_Z80_MACH_EZ80_ADL: strcat (buf, ", EZ80, ADL"); break;
3769 case EF_Z80_MACH_GBZ80: strcat (buf, ", GBZ80"); break;
3770 default:
3771 strcat (buf, _(", unknown")); break;
3772 }
3773 break;
3774 }
3775 }
3776
3777 return buf;
3778 }
3779
3780 static const char *
get_osabi_name(Filedata * filedata,unsigned int osabi)3781 get_osabi_name (Filedata * filedata, unsigned int osabi)
3782 {
3783 static char buff[32];
3784
3785 switch (osabi)
3786 {
3787 case ELFOSABI_NONE: return "UNIX - System V";
3788 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3789 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
3790 case ELFOSABI_GNU: return "UNIX - GNU";
3791 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3792 case ELFOSABI_AIX: return "UNIX - AIX";
3793 case ELFOSABI_IRIX: return "UNIX - IRIX";
3794 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3795 case ELFOSABI_TRU64: return "UNIX - TRU64";
3796 case ELFOSABI_MODESTO: return "Novell - Modesto";
3797 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3798 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3799 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3800 case ELFOSABI_AROS: return "AROS";
3801 case ELFOSABI_FENIXOS: return "FenixOS";
3802 case ELFOSABI_CLOUDABI: return "Nuxi CloudABI";
3803 case ELFOSABI_OPENVOS: return "Stratus Technologies OpenVOS";
3804 default:
3805 if (osabi >= 64)
3806 switch (filedata->file_header.e_machine)
3807 {
3808 case EM_ARM:
3809 switch (osabi)
3810 {
3811 case ELFOSABI_ARM: return "ARM";
3812 case ELFOSABI_ARM_FDPIC: return "ARM FDPIC";
3813 default:
3814 break;
3815 }
3816 break;
3817
3818 case EM_MSP430:
3819 case EM_MSP430_OLD:
3820 case EM_VISIUM:
3821 switch (osabi)
3822 {
3823 case ELFOSABI_STANDALONE: return _("Standalone App");
3824 default:
3825 break;
3826 }
3827 break;
3828
3829 case EM_TI_C6000:
3830 switch (osabi)
3831 {
3832 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3833 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3834 default:
3835 break;
3836 }
3837 break;
3838
3839 default:
3840 break;
3841 }
3842 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3843 return buff;
3844 }
3845 }
3846
3847 static const char *
get_aarch64_segment_type(unsigned long type)3848 get_aarch64_segment_type (unsigned long type)
3849 {
3850 switch (type)
3851 {
3852 case PT_AARCH64_ARCHEXT: return "AARCH64_ARCHEXT";
3853 default: return NULL;
3854 }
3855 }
3856
3857 static const char *
get_arm_segment_type(unsigned long type)3858 get_arm_segment_type (unsigned long type)
3859 {
3860 switch (type)
3861 {
3862 case PT_ARM_EXIDX: return "EXIDX";
3863 default: return NULL;
3864 }
3865 }
3866
3867 static const char *
get_s390_segment_type(unsigned long type)3868 get_s390_segment_type (unsigned long type)
3869 {
3870 switch (type)
3871 {
3872 case PT_S390_PGSTE: return "S390_PGSTE";
3873 default: return NULL;
3874 }
3875 }
3876
3877 static const char *
get_mips_segment_type(unsigned long type)3878 get_mips_segment_type (unsigned long type)
3879 {
3880 switch (type)
3881 {
3882 case PT_MIPS_REGINFO: return "REGINFO";
3883 case PT_MIPS_RTPROC: return "RTPROC";
3884 case PT_MIPS_OPTIONS: return "OPTIONS";
3885 case PT_MIPS_ABIFLAGS: return "ABIFLAGS";
3886 default: return NULL;
3887 }
3888 }
3889
3890 static const char *
get_parisc_segment_type(unsigned long type)3891 get_parisc_segment_type (unsigned long type)
3892 {
3893 switch (type)
3894 {
3895 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3896 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
3897 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
3898 default: return NULL;
3899 }
3900 }
3901
3902 static const char *
get_ia64_segment_type(unsigned long type)3903 get_ia64_segment_type (unsigned long type)
3904 {
3905 switch (type)
3906 {
3907 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3908 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
3909 default: return NULL;
3910 }
3911 }
3912
3913 static const char *
get_tic6x_segment_type(unsigned long type)3914 get_tic6x_segment_type (unsigned long type)
3915 {
3916 switch (type)
3917 {
3918 case PT_C6000_PHATTR: return "C6000_PHATTR";
3919 default: return NULL;
3920 }
3921 }
3922
3923 static const char *
get_hpux_segment_type(unsigned long type,unsigned e_machine)3924 get_hpux_segment_type (unsigned long type, unsigned e_machine)
3925 {
3926 if (e_machine == EM_PARISC)
3927 switch (type)
3928 {
3929 case PT_HP_TLS: return "HP_TLS";
3930 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3931 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3932 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3933 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3934 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3935 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3936 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3937 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3938 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3939 case PT_HP_PARALLEL: return "HP_PARALLEL";
3940 case PT_HP_FASTBIND: return "HP_FASTBIND";
3941 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3942 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3943 case PT_HP_STACK: return "HP_STACK";
3944 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
3945 default: return NULL;
3946 }
3947
3948 if (e_machine == EM_IA_64)
3949 switch (type)
3950 {
3951 case PT_HP_TLS: return "HP_TLS";
3952 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3953 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3954 case PT_IA_64_HP_STACK: return "HP_STACK";
3955 default: return NULL;
3956 }
3957
3958 return NULL;
3959 }
3960
3961 static const char *
get_solaris_segment_type(unsigned long type)3962 get_solaris_segment_type (unsigned long type)
3963 {
3964 switch (type)
3965 {
3966 case 0x6464e550: return "PT_SUNW_UNWIND";
3967 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3968 case 0x6ffffff7: return "PT_LOSUNW";
3969 case 0x6ffffffa: return "PT_SUNWBSS";
3970 case 0x6ffffffb: return "PT_SUNWSTACK";
3971 case 0x6ffffffc: return "PT_SUNWDTRACE";
3972 case 0x6ffffffd: return "PT_SUNWCAP";
3973 case 0x6fffffff: return "PT_HISUNW";
3974 default: return NULL;
3975 }
3976 }
3977
3978 static const char *
get_segment_type(Filedata * filedata,unsigned long p_type)3979 get_segment_type (Filedata * filedata, unsigned long p_type)
3980 {
3981 static char buff[32];
3982
3983 switch (p_type)
3984 {
3985 case PT_NULL: return "NULL";
3986 case PT_LOAD: return "LOAD";
3987 case PT_DYNAMIC: return "DYNAMIC";
3988 case PT_INTERP: return "INTERP";
3989 case PT_NOTE: return "NOTE";
3990 case PT_SHLIB: return "SHLIB";
3991 case PT_PHDR: return "PHDR";
3992 case PT_TLS: return "TLS";
3993 case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
3994 case PT_GNU_STACK: return "GNU_STACK";
3995 case PT_GNU_RELRO: return "GNU_RELRO";
3996 case PT_GNU_PROPERTY: return "GNU_PROPERTY";
3997
3998 default:
3999 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
4000 {
4001 const char * result;
4002
4003 switch (filedata->file_header.e_machine)
4004 {
4005 case EM_AARCH64:
4006 result = get_aarch64_segment_type (p_type);
4007 break;
4008 case EM_ARM:
4009 result = get_arm_segment_type (p_type);
4010 break;
4011 case EM_MIPS:
4012 case EM_MIPS_RS3_LE:
4013 result = get_mips_segment_type (p_type);
4014 break;
4015 case EM_PARISC:
4016 result = get_parisc_segment_type (p_type);
4017 break;
4018 case EM_IA_64:
4019 result = get_ia64_segment_type (p_type);
4020 break;
4021 case EM_TI_C6000:
4022 result = get_tic6x_segment_type (p_type);
4023 break;
4024 case EM_S390:
4025 case EM_S390_OLD:
4026 result = get_s390_segment_type (p_type);
4027 break;
4028 default:
4029 result = NULL;
4030 break;
4031 }
4032
4033 if (result != NULL)
4034 return result;
4035
4036 sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
4037 }
4038 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
4039 {
4040 const char * result = NULL;
4041
4042 switch (filedata->file_header.e_ident[EI_OSABI])
4043 {
4044 case ELFOSABI_GNU:
4045 case ELFOSABI_FREEBSD:
4046 if (p_type >= PT_GNU_MBIND_LO && p_type <= PT_GNU_MBIND_HI)
4047 {
4048 sprintf (buff, "GNU_MBIND+%#lx", p_type - PT_GNU_MBIND_LO);
4049 result = buff;
4050 }
4051 break;
4052 case ELFOSABI_HPUX:
4053 result = get_hpux_segment_type (p_type,
4054 filedata->file_header.e_machine);
4055 break;
4056 case ELFOSABI_SOLARIS:
4057 result = get_solaris_segment_type (p_type);
4058 break;
4059 default:
4060 break;
4061 }
4062 if (result != NULL)
4063 return result;
4064
4065 sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
4066 }
4067 else
4068 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
4069
4070 return buff;
4071 }
4072 }
4073
4074 static const char *
get_arc_section_type_name(unsigned int sh_type)4075 get_arc_section_type_name (unsigned int sh_type)
4076 {
4077 switch (sh_type)
4078 {
4079 case SHT_ARC_ATTRIBUTES: return "ARC_ATTRIBUTES";
4080 default:
4081 break;
4082 }
4083 return NULL;
4084 }
4085
4086 static const char *
get_mips_section_type_name(unsigned int sh_type)4087 get_mips_section_type_name (unsigned int sh_type)
4088 {
4089 switch (sh_type)
4090 {
4091 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
4092 case SHT_MIPS_MSYM: return "MIPS_MSYM";
4093 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
4094 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
4095 case SHT_MIPS_UCODE: return "MIPS_UCODE";
4096 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
4097 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
4098 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
4099 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
4100 case SHT_MIPS_RELD: return "MIPS_RELD";
4101 case SHT_MIPS_IFACE: return "MIPS_IFACE";
4102 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
4103 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
4104 case SHT_MIPS_SHDR: return "MIPS_SHDR";
4105 case SHT_MIPS_FDESC: return "MIPS_FDESC";
4106 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
4107 case SHT_MIPS_DENSE: return "MIPS_DENSE";
4108 case SHT_MIPS_PDESC: return "MIPS_PDESC";
4109 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
4110 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
4111 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
4112 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
4113 case SHT_MIPS_LINE: return "MIPS_LINE";
4114 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
4115 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
4116 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
4117 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
4118 case SHT_MIPS_DWARF: return "MIPS_DWARF";
4119 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
4120 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
4121 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
4122 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
4123 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
4124 case SHT_MIPS_XLATE: return "MIPS_XLATE";
4125 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
4126 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
4127 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
4128 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
4129 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
4130 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
4131 case SHT_MIPS_XHASH: return "MIPS_XHASH";
4132 default:
4133 break;
4134 }
4135 return NULL;
4136 }
4137
4138 static const char *
get_parisc_section_type_name(unsigned int sh_type)4139 get_parisc_section_type_name (unsigned int sh_type)
4140 {
4141 switch (sh_type)
4142 {
4143 case SHT_PARISC_EXT: return "PARISC_EXT";
4144 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
4145 case SHT_PARISC_DOC: return "PARISC_DOC";
4146 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
4147 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
4148 case SHT_PARISC_STUBS: return "PARISC_STUBS";
4149 case SHT_PARISC_DLKM: return "PARISC_DLKM";
4150 default: return NULL;
4151 }
4152 }
4153
4154 static const char *
get_ia64_section_type_name(Filedata * filedata,unsigned int sh_type)4155 get_ia64_section_type_name (Filedata * filedata, unsigned int sh_type)
4156 {
4157 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4158 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
4159 return get_osabi_name (filedata, (sh_type & 0x00FF0000) >> 16);
4160
4161 switch (sh_type)
4162 {
4163 case SHT_IA_64_EXT: return "IA_64_EXT";
4164 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
4165 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
4166 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
4167 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
4168 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
4169 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
4170 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
4171 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
4172 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4173 default:
4174 break;
4175 }
4176 return NULL;
4177 }
4178
4179 static const char *
get_x86_64_section_type_name(unsigned int sh_type)4180 get_x86_64_section_type_name (unsigned int sh_type)
4181 {
4182 switch (sh_type)
4183 {
4184 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
4185 default: return NULL;
4186 }
4187 }
4188
4189 static const char *
get_aarch64_section_type_name(unsigned int sh_type)4190 get_aarch64_section_type_name (unsigned int sh_type)
4191 {
4192 switch (sh_type)
4193 {
4194 case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
4195 default: return NULL;
4196 }
4197 }
4198
4199 static const char *
get_arm_section_type_name(unsigned int sh_type)4200 get_arm_section_type_name (unsigned int sh_type)
4201 {
4202 switch (sh_type)
4203 {
4204 case SHT_ARM_EXIDX: return "ARM_EXIDX";
4205 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
4206 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
4207 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
4208 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
4209 default: return NULL;
4210 }
4211 }
4212
4213 static const char *
get_tic6x_section_type_name(unsigned int sh_type)4214 get_tic6x_section_type_name (unsigned int sh_type)
4215 {
4216 switch (sh_type)
4217 {
4218 case SHT_C6000_UNWIND: return "C6000_UNWIND";
4219 case SHT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
4220 case SHT_C6000_ATTRIBUTES: return "C6000_ATTRIBUTES";
4221 case SHT_TI_ICODE: return "TI_ICODE";
4222 case SHT_TI_XREF: return "TI_XREF";
4223 case SHT_TI_HANDLER: return "TI_HANDLER";
4224 case SHT_TI_INITINFO: return "TI_INITINFO";
4225 case SHT_TI_PHATTRS: return "TI_PHATTRS";
4226 default: return NULL;
4227 }
4228 }
4229
4230 static const char *
get_msp430x_section_type_name(unsigned int sh_type)4231 get_msp430x_section_type_name (unsigned int sh_type)
4232 {
4233 switch (sh_type)
4234 {
4235 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
4236 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
4237 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
4238 default: return NULL;
4239 }
4240 }
4241
4242 static const char *
get_nfp_section_type_name(unsigned int sh_type)4243 get_nfp_section_type_name (unsigned int sh_type)
4244 {
4245 switch (sh_type)
4246 {
4247 case SHT_NFP_MECONFIG: return "NFP_MECONFIG";
4248 case SHT_NFP_INITREG: return "NFP_INITREG";
4249 case SHT_NFP_UDEBUG: return "NFP_UDEBUG";
4250 default: return NULL;
4251 }
4252 }
4253
4254 static const char *
get_v850_section_type_name(unsigned int sh_type)4255 get_v850_section_type_name (unsigned int sh_type)
4256 {
4257 switch (sh_type)
4258 {
4259 case SHT_V850_SCOMMON: return "V850 Small Common";
4260 case SHT_V850_TCOMMON: return "V850 Tiny Common";
4261 case SHT_V850_ZCOMMON: return "V850 Zero Common";
4262 case SHT_RENESAS_IOP: return "RENESAS IOP";
4263 case SHT_RENESAS_INFO: return "RENESAS INFO";
4264 default: return NULL;
4265 }
4266 }
4267
4268 static const char *
get_riscv_section_type_name(unsigned int sh_type)4269 get_riscv_section_type_name (unsigned int sh_type)
4270 {
4271 switch (sh_type)
4272 {
4273 case SHT_RISCV_ATTRIBUTES: return "RISCV_ATTRIBUTES";
4274 default: return NULL;
4275 }
4276 }
4277
4278 static const char *
get_section_type_name(Filedata * filedata,unsigned int sh_type)4279 get_section_type_name (Filedata * filedata, unsigned int sh_type)
4280 {
4281 static char buff[32];
4282 const char * result;
4283
4284 switch (sh_type)
4285 {
4286 case SHT_NULL: return "NULL";
4287 case SHT_PROGBITS: return "PROGBITS";
4288 case SHT_SYMTAB: return "SYMTAB";
4289 case SHT_STRTAB: return "STRTAB";
4290 case SHT_RELA: return "RELA";
4291 case SHT_HASH: return "HASH";
4292 case SHT_DYNAMIC: return "DYNAMIC";
4293 case SHT_NOTE: return "NOTE";
4294 case SHT_NOBITS: return "NOBITS";
4295 case SHT_REL: return "REL";
4296 case SHT_SHLIB: return "SHLIB";
4297 case SHT_DYNSYM: return "DYNSYM";
4298 case SHT_INIT_ARRAY: return "INIT_ARRAY";
4299 case SHT_FINI_ARRAY: return "FINI_ARRAY";
4300 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
4301 case SHT_GNU_HASH: return "GNU_HASH";
4302 case SHT_GROUP: return "GROUP";
4303 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICES";
4304 case SHT_GNU_verdef: return "VERDEF";
4305 case SHT_GNU_verneed: return "VERNEED";
4306 case SHT_GNU_versym: return "VERSYM";
4307 case 0x6ffffff0: return "VERSYM";
4308 case 0x6ffffffc: return "VERDEF";
4309 case 0x7ffffffd: return "AUXILIARY";
4310 case 0x7fffffff: return "FILTER";
4311 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
4312
4313 default:
4314 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4315 {
4316 switch (filedata->file_header.e_machine)
4317 {
4318 case EM_ARC:
4319 case EM_ARC_COMPACT:
4320 case EM_ARC_COMPACT2:
4321 result = get_arc_section_type_name (sh_type);
4322 break;
4323 case EM_MIPS:
4324 case EM_MIPS_RS3_LE:
4325 result = get_mips_section_type_name (sh_type);
4326 break;
4327 case EM_PARISC:
4328 result = get_parisc_section_type_name (sh_type);
4329 break;
4330 case EM_IA_64:
4331 result = get_ia64_section_type_name (filedata, sh_type);
4332 break;
4333 case EM_X86_64:
4334 case EM_L1OM:
4335 case EM_K1OM:
4336 result = get_x86_64_section_type_name (sh_type);
4337 break;
4338 case EM_AARCH64:
4339 result = get_aarch64_section_type_name (sh_type);
4340 break;
4341 case EM_ARM:
4342 result = get_arm_section_type_name (sh_type);
4343 break;
4344 case EM_TI_C6000:
4345 result = get_tic6x_section_type_name (sh_type);
4346 break;
4347 case EM_MSP430:
4348 result = get_msp430x_section_type_name (sh_type);
4349 break;
4350 case EM_NFP:
4351 result = get_nfp_section_type_name (sh_type);
4352 break;
4353 case EM_V800:
4354 case EM_V850:
4355 case EM_CYGNUS_V850:
4356 result = get_v850_section_type_name (sh_type);
4357 break;
4358 case EM_RISCV:
4359 result = get_riscv_section_type_name (sh_type);
4360 break;
4361 default:
4362 result = NULL;
4363 break;
4364 }
4365
4366 if (result != NULL)
4367 return result;
4368
4369 sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
4370 }
4371 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
4372 {
4373 switch (filedata->file_header.e_machine)
4374 {
4375 case EM_IA_64:
4376 result = get_ia64_section_type_name (filedata, sh_type);
4377 break;
4378 default:
4379 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4380 result = get_solaris_section_type (sh_type);
4381 else
4382 {
4383 switch (sh_type)
4384 {
4385 case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
4386 case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
4387 case SHT_GNU_HASH: result = "GNU_HASH"; break;
4388 case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
4389 default:
4390 result = NULL;
4391 break;
4392 }
4393 }
4394 break;
4395 }
4396
4397 if (result != NULL)
4398 return result;
4399
4400 sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
4401 }
4402 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
4403 {
4404 switch (filedata->file_header.e_machine)
4405 {
4406 case EM_V800:
4407 case EM_V850:
4408 case EM_CYGNUS_V850:
4409 result = get_v850_section_type_name (sh_type);
4410 break;
4411 default:
4412 result = NULL;
4413 break;
4414 }
4415
4416 if (result != NULL)
4417 return result;
4418
4419 sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4420 }
4421 else
4422 /* This message is probably going to be displayed in a 15
4423 character wide field, so put the hex value first. */
4424 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
4425
4426 return buff;
4427 }
4428 }
4429
4430 #define OPTION_DEBUG_DUMP 512
4431 #define OPTION_DYN_SYMS 513
4432 #define OPTION_DWARF_DEPTH 514
4433 #define OPTION_DWARF_START 515
4434 #define OPTION_DWARF_CHECK 516
4435 #define OPTION_CTF_DUMP 517
4436 #define OPTION_CTF_PARENT 518
4437 #define OPTION_CTF_SYMBOLS 519
4438 #define OPTION_CTF_STRINGS 520
4439
4440 static struct option options[] =
4441 {
4442 {"all", no_argument, 0, 'a'},
4443 {"file-header", no_argument, 0, 'h'},
4444 {"program-headers", no_argument, 0, 'l'},
4445 {"headers", no_argument, 0, 'e'},
4446 {"histogram", no_argument, 0, 'I'},
4447 {"segments", no_argument, 0, 'l'},
4448 {"sections", no_argument, 0, 'S'},
4449 {"section-headers", no_argument, 0, 'S'},
4450 {"section-groups", no_argument, 0, 'g'},
4451 {"section-details", no_argument, 0, 't'},
4452 {"full-section-name",no_argument, 0, 'N'},
4453 {"symbols", no_argument, 0, 's'},
4454 {"syms", no_argument, 0, 's'},
4455 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
4456 {"relocs", no_argument, 0, 'r'},
4457 {"notes", no_argument, 0, 'n'},
4458 {"dynamic", no_argument, 0, 'd'},
4459 {"arch-specific", no_argument, 0, 'A'},
4460 {"version-info", no_argument, 0, 'V'},
4461 {"use-dynamic", no_argument, 0, 'D'},
4462 {"unwind", no_argument, 0, 'u'},
4463 {"archive-index", no_argument, 0, 'c'},
4464 {"hex-dump", required_argument, 0, 'x'},
4465 {"relocated-dump", required_argument, 0, 'R'},
4466 {"string-dump", required_argument, 0, 'p'},
4467 {"decompress", no_argument, 0, 'z'},
4468 #ifdef SUPPORT_DISASSEMBLY
4469 {"instruction-dump", required_argument, 0, 'i'},
4470 #endif
4471 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
4472
4473 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
4474 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4475 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
4476
4477 {"ctf", required_argument, 0, OPTION_CTF_DUMP},
4478
4479 {"ctf-symbols", required_argument, 0, OPTION_CTF_SYMBOLS},
4480 {"ctf-strings", required_argument, 0, OPTION_CTF_STRINGS},
4481 {"ctf-parent", required_argument, 0, OPTION_CTF_PARENT},
4482
4483 {"version", no_argument, 0, 'v'},
4484 {"wide", no_argument, 0, 'W'},
4485 {"help", no_argument, 0, 'H'},
4486 {0, no_argument, 0, 0}
4487 };
4488
4489 static void
usage(FILE * stream)4490 usage (FILE * stream)
4491 {
4492 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4493 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4494 fprintf (stream, _(" Options are:\n\
4495 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4496 -h --file-header Display the ELF file header\n\
4497 -l --program-headers Display the program headers\n\
4498 --segments An alias for --program-headers\n\
4499 -S --section-headers Display the sections' header\n\
4500 --sections An alias for --section-headers\n\
4501 -g --section-groups Display the section groups\n\
4502 -t --section-details Display the section details\n\
4503 -e --headers Equivalent to: -h -l -S\n\
4504 -s --syms Display the symbol table\n\
4505 --symbols An alias for --syms\n\
4506 --dyn-syms Display the dynamic symbol table\n\
4507 -n --notes Display the core notes (if present)\n\
4508 -r --relocs Display the relocations (if present)\n\
4509 -u --unwind Display the unwind info (if present)\n\
4510 -d --dynamic Display the dynamic section (if present)\n\
4511 -V --version-info Display the version sections (if present)\n\
4512 -A --arch-specific Display architecture specific information (if any)\n\
4513 -c --archive-index Display the symbol/file index in an archive\n\
4514 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4515 -x --hex-dump=<number|name>\n\
4516 Dump the contents of section <number|name> as bytes\n\
4517 -p --string-dump=<number|name>\n\
4518 Dump the contents of section <number|name> as strings\n\
4519 -R --relocated-dump=<number|name>\n\
4520 Dump the contents of section <number|name> as relocated bytes\n\
4521 -z --decompress Decompress section before dumping it\n\
4522 -w[lLiaprmfFsoRtUuTgAckK] or\n\
4523 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4524 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4525 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4526 =addr,=cu_index,=links,=follow-links]\n\
4527 Display the contents of DWARF debug sections\n"));
4528 fprintf (stream, _("\
4529 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4530 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4531 or deeper\n"));
4532 fprintf (stream, _("\
4533 --ctf=<number|name> Display CTF info from section <number|name>\n\
4534 --ctf-parent=<number|name>\n\
4535 Use section <number|name> as the CTF parent\n\n\
4536 --ctf-symbols=<number|name>\n\
4537 Use section <number|name> as the CTF external symtab\n\n\
4538 --ctf-strings=<number|name>\n\
4539 Use section <number|name> as the CTF external strtab\n\n"));
4540
4541 #ifdef SUPPORT_DISASSEMBLY
4542 fprintf (stream, _("\
4543 -i --instruction-dump=<number|name>\n\
4544 Disassemble the contents of section <number|name>\n"));
4545 #endif
4546 fprintf (stream, _("\
4547 -I --histogram Display histogram of bucket list lengths\n\
4548 -W --wide Allow output width to exceed 80 characters\n\
4549 @<file> Read options from <file>\n\
4550 -H --help Display this information\n\
4551 -v --version Display the version number of readelf\n"));
4552
4553 if (REPORT_BUGS_TO[0] && stream == stdout)
4554 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4555
4556 exit (stream == stdout ? 0 : 1);
4557 }
4558
4559 /* Record the fact that the user wants the contents of section number
4560 SECTION to be displayed using the method(s) encoded as flags bits
4561 in TYPE. Note, TYPE can be zero if we are creating the array for
4562 the first time. */
4563
4564 static void
request_dump_bynumber(Filedata * filedata,unsigned int section,dump_type type)4565 request_dump_bynumber (Filedata * filedata, unsigned int section, dump_type type)
4566 {
4567 if (section >= filedata->num_dump_sects)
4568 {
4569 dump_type * new_dump_sects;
4570
4571 new_dump_sects = (dump_type *) calloc (section + 1,
4572 sizeof (* new_dump_sects));
4573
4574 if (new_dump_sects == NULL)
4575 error (_("Out of memory allocating dump request table.\n"));
4576 else
4577 {
4578 if (filedata->dump_sects)
4579 {
4580 /* Copy current flag settings. */
4581 memcpy (new_dump_sects, filedata->dump_sects,
4582 filedata->num_dump_sects * sizeof (* new_dump_sects));
4583
4584 free (filedata->dump_sects);
4585 }
4586
4587 filedata->dump_sects = new_dump_sects;
4588 filedata->num_dump_sects = section + 1;
4589 }
4590 }
4591
4592 if (filedata->dump_sects)
4593 filedata->dump_sects[section] |= type;
4594 }
4595
4596 /* Request a dump by section name. */
4597
4598 static void
request_dump_byname(const char * section,dump_type type)4599 request_dump_byname (const char * section, dump_type type)
4600 {
4601 struct dump_list_entry * new_request;
4602
4603 new_request = (struct dump_list_entry *)
4604 malloc (sizeof (struct dump_list_entry));
4605 if (!new_request)
4606 error (_("Out of memory allocating dump request table.\n"));
4607
4608 new_request->name = strdup (section);
4609 if (!new_request->name)
4610 error (_("Out of memory allocating dump request table.\n"));
4611
4612 new_request->type = type;
4613
4614 new_request->next = dump_sects_byname;
4615 dump_sects_byname = new_request;
4616 }
4617
4618 static inline void
request_dump(Filedata * filedata,dump_type type)4619 request_dump (Filedata * filedata, dump_type type)
4620 {
4621 int section;
4622 char * cp;
4623
4624 do_dump++;
4625 section = strtoul (optarg, & cp, 0);
4626
4627 if (! *cp && section >= 0)
4628 request_dump_bynumber (filedata, section, type);
4629 else
4630 request_dump_byname (optarg, type);
4631 }
4632
4633 static void
parse_args(Filedata * filedata,int argc,char ** argv)4634 parse_args (Filedata * filedata, int argc, char ** argv)
4635 {
4636 int c;
4637
4638 if (argc < 2)
4639 usage (stderr);
4640
4641 while ((c = getopt_long
4642 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4643 {
4644 switch (c)
4645 {
4646 case 0:
4647 /* Long options. */
4648 break;
4649 case 'H':
4650 usage (stdout);
4651 break;
4652
4653 case 'a':
4654 do_syms = TRUE;
4655 do_reloc = TRUE;
4656 do_unwind = TRUE;
4657 do_dynamic = TRUE;
4658 do_header = TRUE;
4659 do_sections = TRUE;
4660 do_section_groups = TRUE;
4661 do_segments = TRUE;
4662 do_version = TRUE;
4663 do_histogram = TRUE;
4664 do_arch = TRUE;
4665 do_notes = TRUE;
4666 break;
4667 case 'g':
4668 do_section_groups = TRUE;
4669 break;
4670 case 't':
4671 case 'N':
4672 do_sections = TRUE;
4673 do_section_details = TRUE;
4674 break;
4675 case 'e':
4676 do_header = TRUE;
4677 do_sections = TRUE;
4678 do_segments = TRUE;
4679 break;
4680 case 'A':
4681 do_arch = TRUE;
4682 break;
4683 case 'D':
4684 do_using_dynamic = TRUE;
4685 break;
4686 case 'r':
4687 do_reloc = TRUE;
4688 break;
4689 case 'u':
4690 do_unwind = TRUE;
4691 break;
4692 case 'h':
4693 do_header = TRUE;
4694 break;
4695 case 'l':
4696 do_segments = TRUE;
4697 break;
4698 case 's':
4699 do_syms = TRUE;
4700 break;
4701 case 'S':
4702 do_sections = TRUE;
4703 break;
4704 case 'd':
4705 do_dynamic = TRUE;
4706 break;
4707 case 'I':
4708 do_histogram = TRUE;
4709 break;
4710 case 'n':
4711 do_notes = TRUE;
4712 break;
4713 case 'c':
4714 do_archive_index = TRUE;
4715 break;
4716 case 'x':
4717 request_dump (filedata, HEX_DUMP);
4718 break;
4719 case 'p':
4720 request_dump (filedata, STRING_DUMP);
4721 break;
4722 case 'R':
4723 request_dump (filedata, RELOC_DUMP);
4724 break;
4725 case 'z':
4726 decompress_dumps = TRUE;
4727 break;
4728 case 'w':
4729 do_dump = TRUE;
4730 if (optarg == 0)
4731 {
4732 do_debugging = TRUE;
4733 dwarf_select_sections_all ();
4734 }
4735 else
4736 {
4737 do_debugging = FALSE;
4738 dwarf_select_sections_by_letters (optarg);
4739 }
4740 break;
4741 case OPTION_DEBUG_DUMP:
4742 do_dump = TRUE;
4743 if (optarg == 0)
4744 do_debugging = TRUE;
4745 else
4746 {
4747 do_debugging = FALSE;
4748 dwarf_select_sections_by_names (optarg);
4749 }
4750 break;
4751 case OPTION_DWARF_DEPTH:
4752 {
4753 char *cp;
4754
4755 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4756 }
4757 break;
4758 case OPTION_DWARF_START:
4759 {
4760 char *cp;
4761
4762 dwarf_start_die = strtoul (optarg, & cp, 0);
4763 }
4764 break;
4765 case OPTION_DWARF_CHECK:
4766 dwarf_check = TRUE;
4767 break;
4768 case OPTION_CTF_DUMP:
4769 do_ctf = TRUE;
4770 request_dump (filedata, CTF_DUMP);
4771 break;
4772 case OPTION_CTF_SYMBOLS:
4773 dump_ctf_symtab_name = strdup (optarg);
4774 break;
4775 case OPTION_CTF_STRINGS:
4776 dump_ctf_strtab_name = strdup (optarg);
4777 break;
4778 case OPTION_CTF_PARENT:
4779 dump_ctf_parent_name = strdup (optarg);
4780 break;
4781 case OPTION_DYN_SYMS:
4782 do_dyn_syms = TRUE;
4783 break;
4784 #ifdef SUPPORT_DISASSEMBLY
4785 case 'i':
4786 request_dump (filedata, DISASS_DUMP);
4787 break;
4788 #endif
4789 case 'v':
4790 print_version (program_name);
4791 break;
4792 case 'V':
4793 do_version = TRUE;
4794 break;
4795 case 'W':
4796 do_wide = TRUE;
4797 break;
4798 default:
4799 /* xgettext:c-format */
4800 error (_("Invalid option '-%c'\n"), c);
4801 /* Fall through. */
4802 case '?':
4803 usage (stderr);
4804 }
4805 }
4806
4807 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4808 && !do_segments && !do_header && !do_dump && !do_version
4809 && !do_histogram && !do_debugging && !do_arch && !do_notes
4810 && !do_section_groups && !do_archive_index
4811 && !do_dyn_syms)
4812 usage (stderr);
4813 }
4814
4815 static const char *
get_elf_class(unsigned int elf_class)4816 get_elf_class (unsigned int elf_class)
4817 {
4818 static char buff[32];
4819
4820 switch (elf_class)
4821 {
4822 case ELFCLASSNONE: return _("none");
4823 case ELFCLASS32: return "ELF32";
4824 case ELFCLASS64: return "ELF64";
4825 default:
4826 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4827 return buff;
4828 }
4829 }
4830
4831 static const char *
get_data_encoding(unsigned int encoding)4832 get_data_encoding (unsigned int encoding)
4833 {
4834 static char buff[32];
4835
4836 switch (encoding)
4837 {
4838 case ELFDATANONE: return _("none");
4839 case ELFDATA2LSB: return _("2's complement, little endian");
4840 case ELFDATA2MSB: return _("2's complement, big endian");
4841 default:
4842 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4843 return buff;
4844 }
4845 }
4846
4847 /* Decode the data held in 'filedata->file_header'. */
4848
4849 static bfd_boolean
process_file_header(Filedata * filedata)4850 process_file_header (Filedata * filedata)
4851 {
4852 Elf_Internal_Ehdr * header = & filedata->file_header;
4853
4854 if ( header->e_ident[EI_MAG0] != ELFMAG0
4855 || header->e_ident[EI_MAG1] != ELFMAG1
4856 || header->e_ident[EI_MAG2] != ELFMAG2
4857 || header->e_ident[EI_MAG3] != ELFMAG3)
4858 {
4859 error
4860 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4861 return FALSE;
4862 }
4863
4864 init_dwarf_regnames_by_elf_machine_code (header->e_machine);
4865
4866 if (do_header)
4867 {
4868 unsigned i;
4869
4870 printf (_("ELF Header:\n"));
4871 printf (_(" Magic: "));
4872 for (i = 0; i < EI_NIDENT; i++)
4873 printf ("%2.2x ", header->e_ident[i]);
4874 printf ("\n");
4875 printf (_(" Class: %s\n"),
4876 get_elf_class (header->e_ident[EI_CLASS]));
4877 printf (_(" Data: %s\n"),
4878 get_data_encoding (header->e_ident[EI_DATA]));
4879 printf (_(" Version: %d%s\n"),
4880 header->e_ident[EI_VERSION],
4881 (header->e_ident[EI_VERSION] == EV_CURRENT
4882 ? _(" (current)")
4883 : (header->e_ident[EI_VERSION] != EV_NONE
4884 ? _(" <unknown>")
4885 : "")));
4886 printf (_(" OS/ABI: %s\n"),
4887 get_osabi_name (filedata, header->e_ident[EI_OSABI]));
4888 printf (_(" ABI Version: %d\n"),
4889 header->e_ident[EI_ABIVERSION]);
4890 printf (_(" Type: %s\n"),
4891 get_file_type (header->e_type));
4892 printf (_(" Machine: %s\n"),
4893 get_machine_name (header->e_machine));
4894 printf (_(" Version: 0x%lx\n"),
4895 header->e_version);
4896
4897 printf (_(" Entry point address: "));
4898 print_vma (header->e_entry, PREFIX_HEX);
4899 printf (_("\n Start of program headers: "));
4900 print_vma (header->e_phoff, DEC);
4901 printf (_(" (bytes into file)\n Start of section headers: "));
4902 print_vma (header->e_shoff, DEC);
4903 printf (_(" (bytes into file)\n"));
4904
4905 printf (_(" Flags: 0x%lx%s\n"),
4906 header->e_flags,
4907 get_machine_flags (filedata, header->e_flags, header->e_machine));
4908 printf (_(" Size of this header: %u (bytes)\n"),
4909 header->e_ehsize);
4910 printf (_(" Size of program headers: %u (bytes)\n"),
4911 header->e_phentsize);
4912 printf (_(" Number of program headers: %u"),
4913 header->e_phnum);
4914 if (filedata->section_headers != NULL
4915 && header->e_phnum == PN_XNUM
4916 && filedata->section_headers[0].sh_info != 0)
4917 {
4918 header->e_phnum = filedata->section_headers[0].sh_info;
4919 printf (" (%u)", header->e_phnum);
4920 }
4921 putc ('\n', stdout);
4922 printf (_(" Size of section headers: %u (bytes)\n"),
4923 header->e_shentsize);
4924 printf (_(" Number of section headers: %u"),
4925 header->e_shnum);
4926 if (filedata->section_headers != NULL && header->e_shnum == SHN_UNDEF)
4927 {
4928 header->e_shnum = filedata->section_headers[0].sh_size;
4929 printf (" (%u)", header->e_shnum);
4930 }
4931 putc ('\n', stdout);
4932 printf (_(" Section header string table index: %u"),
4933 header->e_shstrndx);
4934 if (filedata->section_headers != NULL
4935 && header->e_shstrndx == (SHN_XINDEX & 0xffff))
4936 {
4937 header->e_shstrndx = filedata->section_headers[0].sh_link;
4938 printf (" (%u)", header->e_shstrndx);
4939 }
4940 if (header->e_shstrndx != SHN_UNDEF
4941 && header->e_shstrndx >= header->e_shnum)
4942 {
4943 header->e_shstrndx = SHN_UNDEF;
4944 printf (_(" <corrupt: out of range>"));
4945 }
4946 putc ('\n', stdout);
4947 }
4948
4949 if (filedata->section_headers != NULL)
4950 {
4951 if (header->e_phnum == PN_XNUM
4952 && filedata->section_headers[0].sh_info != 0)
4953 header->e_phnum = filedata->section_headers[0].sh_info;
4954 if (header->e_shnum == SHN_UNDEF)
4955 header->e_shnum = filedata->section_headers[0].sh_size;
4956 if (header->e_shstrndx == (SHN_XINDEX & 0xffff))
4957 header->e_shstrndx = filedata->section_headers[0].sh_link;
4958 if (header->e_shstrndx >= header->e_shnum)
4959 header->e_shstrndx = SHN_UNDEF;
4960 free (filedata->section_headers);
4961 filedata->section_headers = NULL;
4962 }
4963
4964 return TRUE;
4965 }
4966
4967 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4968 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
4969
4970 static bfd_boolean
get_32bit_program_headers(Filedata * filedata,Elf_Internal_Phdr * pheaders)4971 get_32bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4972 {
4973 Elf32_External_Phdr * phdrs;
4974 Elf32_External_Phdr * external;
4975 Elf_Internal_Phdr * internal;
4976 unsigned int i;
4977 unsigned int size = filedata->file_header.e_phentsize;
4978 unsigned int num = filedata->file_header.e_phnum;
4979
4980 /* PR binutils/17531: Cope with unexpected section header sizes. */
4981 if (size == 0 || num == 0)
4982 return FALSE;
4983 if (size < sizeof * phdrs)
4984 {
4985 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4986 return FALSE;
4987 }
4988 if (size > sizeof * phdrs)
4989 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4990
4991 phdrs = (Elf32_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4992 size, num, _("program headers"));
4993 if (phdrs == NULL)
4994 return FALSE;
4995
4996 for (i = 0, internal = pheaders, external = phdrs;
4997 i < filedata->file_header.e_phnum;
4998 i++, internal++, external++)
4999 {
5000 internal->p_type = BYTE_GET (external->p_type);
5001 internal->p_offset = BYTE_GET (external->p_offset);
5002 internal->p_vaddr = BYTE_GET (external->p_vaddr);
5003 internal->p_paddr = BYTE_GET (external->p_paddr);
5004 internal->p_filesz = BYTE_GET (external->p_filesz);
5005 internal->p_memsz = BYTE_GET (external->p_memsz);
5006 internal->p_flags = BYTE_GET (external->p_flags);
5007 internal->p_align = BYTE_GET (external->p_align);
5008 }
5009
5010 free (phdrs);
5011 return TRUE;
5012 }
5013
5014 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5015 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
5016
5017 static bfd_boolean
get_64bit_program_headers(Filedata * filedata,Elf_Internal_Phdr * pheaders)5018 get_64bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
5019 {
5020 Elf64_External_Phdr * phdrs;
5021 Elf64_External_Phdr * external;
5022 Elf_Internal_Phdr * internal;
5023 unsigned int i;
5024 unsigned int size = filedata->file_header.e_phentsize;
5025 unsigned int num = filedata->file_header.e_phnum;
5026
5027 /* PR binutils/17531: Cope with unexpected section header sizes. */
5028 if (size == 0 || num == 0)
5029 return FALSE;
5030 if (size < sizeof * phdrs)
5031 {
5032 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5033 return FALSE;
5034 }
5035 if (size > sizeof * phdrs)
5036 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5037
5038 phdrs = (Elf64_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
5039 size, num, _("program headers"));
5040 if (!phdrs)
5041 return FALSE;
5042
5043 for (i = 0, internal = pheaders, external = phdrs;
5044 i < filedata->file_header.e_phnum;
5045 i++, internal++, external++)
5046 {
5047 internal->p_type = BYTE_GET (external->p_type);
5048 internal->p_flags = BYTE_GET (external->p_flags);
5049 internal->p_offset = BYTE_GET (external->p_offset);
5050 internal->p_vaddr = BYTE_GET (external->p_vaddr);
5051 internal->p_paddr = BYTE_GET (external->p_paddr);
5052 internal->p_filesz = BYTE_GET (external->p_filesz);
5053 internal->p_memsz = BYTE_GET (external->p_memsz);
5054 internal->p_align = BYTE_GET (external->p_align);
5055 }
5056
5057 free (phdrs);
5058 return TRUE;
5059 }
5060
5061 /* Returns TRUE if the program headers were read into `program_headers'. */
5062
5063 static bfd_boolean
get_program_headers(Filedata * filedata)5064 get_program_headers (Filedata * filedata)
5065 {
5066 Elf_Internal_Phdr * phdrs;
5067
5068 /* Check cache of prior read. */
5069 if (filedata->program_headers != NULL)
5070 return TRUE;
5071
5072 /* Be kind to memory checkers by looking for
5073 e_phnum values which we know must be invalid. */
5074 if (filedata->file_header.e_phnum
5075 * (is_32bit_elf ? sizeof (Elf32_External_Phdr) : sizeof (Elf64_External_Phdr))
5076 >= filedata->file_size)
5077 {
5078 error (_("Too many program headers - %#x - the file is not that big\n"),
5079 filedata->file_header.e_phnum);
5080 return FALSE;
5081 }
5082
5083 phdrs = (Elf_Internal_Phdr *) cmalloc (filedata->file_header.e_phnum,
5084 sizeof (Elf_Internal_Phdr));
5085 if (phdrs == NULL)
5086 {
5087 error (_("Out of memory reading %u program headers\n"),
5088 filedata->file_header.e_phnum);
5089 return FALSE;
5090 }
5091
5092 if (is_32bit_elf
5093 ? get_32bit_program_headers (filedata, phdrs)
5094 : get_64bit_program_headers (filedata, phdrs))
5095 {
5096 filedata->program_headers = phdrs;
5097 return TRUE;
5098 }
5099
5100 free (phdrs);
5101 return FALSE;
5102 }
5103
5104 /* Returns TRUE if the program headers were loaded. */
5105
5106 static bfd_boolean
process_program_headers(Filedata * filedata)5107 process_program_headers (Filedata * filedata)
5108 {
5109 Elf_Internal_Phdr * segment;
5110 unsigned int i;
5111 Elf_Internal_Phdr * previous_load = NULL;
5112
5113 dynamic_addr = 0;
5114 dynamic_size = 0;
5115
5116 if (filedata->file_header.e_phnum == 0)
5117 {
5118 /* PR binutils/12467. */
5119 if (filedata->file_header.e_phoff != 0)
5120 {
5121 warn (_("possibly corrupt ELF header - it has a non-zero program"
5122 " header offset, but no program headers\n"));
5123 return FALSE;
5124 }
5125 else if (do_segments)
5126 printf (_("\nThere are no program headers in this file.\n"));
5127 return TRUE;
5128 }
5129
5130 if (do_segments && !do_header)
5131 {
5132 printf (_("\nElf file type is %s\n"), get_file_type (filedata->file_header.e_type));
5133 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata->file_header.e_entry));
5134 printf (ngettext ("There is %d program header, starting at offset %s\n",
5135 "There are %d program headers, starting at offset %s\n",
5136 filedata->file_header.e_phnum),
5137 filedata->file_header.e_phnum,
5138 bfd_vmatoa ("u", filedata->file_header.e_phoff));
5139 }
5140
5141 if (! get_program_headers (filedata))
5142 return TRUE;
5143
5144 if (do_segments)
5145 {
5146 if (filedata->file_header.e_phnum > 1)
5147 printf (_("\nProgram Headers:\n"));
5148 else
5149 printf (_("\nProgram Headers:\n"));
5150
5151 if (is_32bit_elf)
5152 printf
5153 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5154 else if (do_wide)
5155 printf
5156 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5157 else
5158 {
5159 printf
5160 (_(" Type Offset VirtAddr PhysAddr\n"));
5161 printf
5162 (_(" FileSiz MemSiz Flags Align\n"));
5163 }
5164 }
5165
5166 for (i = 0, segment = filedata->program_headers;
5167 i < filedata->file_header.e_phnum;
5168 i++, segment++)
5169 {
5170 if (do_segments)
5171 {
5172 printf (" %-14.14s ", get_segment_type (filedata, segment->p_type));
5173
5174 if (is_32bit_elf)
5175 {
5176 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5177 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
5178 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
5179 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
5180 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
5181 printf ("%c%c%c ",
5182 (segment->p_flags & PF_R ? 'R' : ' '),
5183 (segment->p_flags & PF_W ? 'W' : ' '),
5184 (segment->p_flags & PF_X ? 'E' : ' '));
5185 printf ("%#lx", (unsigned long) segment->p_align);
5186 }
5187 else if (do_wide)
5188 {
5189 if ((unsigned long) segment->p_offset == segment->p_offset)
5190 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5191 else
5192 {
5193 print_vma (segment->p_offset, FULL_HEX);
5194 putchar (' ');
5195 }
5196
5197 print_vma (segment->p_vaddr, FULL_HEX);
5198 putchar (' ');
5199 print_vma (segment->p_paddr, FULL_HEX);
5200 putchar (' ');
5201
5202 if ((unsigned long) segment->p_filesz == segment->p_filesz)
5203 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
5204 else
5205 {
5206 print_vma (segment->p_filesz, FULL_HEX);
5207 putchar (' ');
5208 }
5209
5210 if ((unsigned long) segment->p_memsz == segment->p_memsz)
5211 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
5212 else
5213 {
5214 print_vma (segment->p_memsz, FULL_HEX);
5215 }
5216
5217 printf (" %c%c%c ",
5218 (segment->p_flags & PF_R ? 'R' : ' '),
5219 (segment->p_flags & PF_W ? 'W' : ' '),
5220 (segment->p_flags & PF_X ? 'E' : ' '));
5221
5222 if ((unsigned long) segment->p_align == segment->p_align)
5223 printf ("%#lx", (unsigned long) segment->p_align);
5224 else
5225 {
5226 print_vma (segment->p_align, PREFIX_HEX);
5227 }
5228 }
5229 else
5230 {
5231 print_vma (segment->p_offset, FULL_HEX);
5232 putchar (' ');
5233 print_vma (segment->p_vaddr, FULL_HEX);
5234 putchar (' ');
5235 print_vma (segment->p_paddr, FULL_HEX);
5236 printf ("\n ");
5237 print_vma (segment->p_filesz, FULL_HEX);
5238 putchar (' ');
5239 print_vma (segment->p_memsz, FULL_HEX);
5240 printf (" %c%c%c ",
5241 (segment->p_flags & PF_R ? 'R' : ' '),
5242 (segment->p_flags & PF_W ? 'W' : ' '),
5243 (segment->p_flags & PF_X ? 'E' : ' '));
5244 print_vma (segment->p_align, PREFIX_HEX);
5245 }
5246
5247 putc ('\n', stdout);
5248 }
5249
5250 switch (segment->p_type)
5251 {
5252 case PT_LOAD:
5253 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5254 required by the ELF standard, several programs, including the Linux
5255 kernel, make use of non-ordered segments. */
5256 if (previous_load
5257 && previous_load->p_vaddr > segment->p_vaddr)
5258 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5259 #endif
5260 if (segment->p_memsz < segment->p_filesz)
5261 error (_("the segment's file size is larger than its memory size\n"));
5262 previous_load = segment;
5263 break;
5264
5265 case PT_PHDR:
5266 /* PR 20815 - Verify that the program header is loaded into memory. */
5267 if (i > 0 && previous_load != NULL)
5268 error (_("the PHDR segment must occur before any LOAD segment\n"));
5269 if (filedata->file_header.e_machine != EM_PARISC)
5270 {
5271 unsigned int j;
5272
5273 for (j = 1; j < filedata->file_header.e_phnum; j++)
5274 {
5275 Elf_Internal_Phdr *load = filedata->program_headers + j;
5276 if (load->p_type == PT_LOAD
5277 && load->p_offset <= segment->p_offset
5278 && (load->p_offset + load->p_filesz
5279 >= segment->p_offset + segment->p_filesz)
5280 && load->p_vaddr <= segment->p_vaddr
5281 && (load->p_vaddr + load->p_filesz
5282 >= segment->p_vaddr + segment->p_filesz))
5283 break;
5284 }
5285 if (j == filedata->file_header.e_phnum)
5286 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5287 }
5288 break;
5289
5290 case PT_DYNAMIC:
5291 if (dynamic_addr)
5292 error (_("more than one dynamic segment\n"));
5293
5294 /* By default, assume that the .dynamic section is the first
5295 section in the DYNAMIC segment. */
5296 dynamic_addr = segment->p_offset;
5297 dynamic_size = segment->p_filesz;
5298
5299 /* Try to locate the .dynamic section. If there is
5300 a section header table, we can easily locate it. */
5301 if (filedata->section_headers != NULL)
5302 {
5303 Elf_Internal_Shdr * sec;
5304
5305 sec = find_section (filedata, ".dynamic");
5306 if (sec == NULL || sec->sh_size == 0)
5307 {
5308 /* A corresponding .dynamic section is expected, but on
5309 IA-64/OpenVMS it is OK for it to be missing. */
5310 if (!is_ia64_vms (filedata))
5311 error (_("no .dynamic section in the dynamic segment\n"));
5312 break;
5313 }
5314
5315 if (sec->sh_type == SHT_NOBITS)
5316 {
5317 dynamic_size = 0;
5318 break;
5319 }
5320
5321 dynamic_addr = sec->sh_offset;
5322 dynamic_size = sec->sh_size;
5323
5324 if (dynamic_addr < segment->p_offset
5325 || dynamic_addr > segment->p_offset + segment->p_filesz)
5326 warn (_("the .dynamic section is not contained"
5327 " within the dynamic segment\n"));
5328 else if (dynamic_addr > segment->p_offset)
5329 warn (_("the .dynamic section is not the first section"
5330 " in the dynamic segment.\n"));
5331 }
5332
5333 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5334 segment. Check this after matching against the section headers
5335 so we don't warn on debuginfo file (which have NOBITS .dynamic
5336 sections). */
5337 if (dynamic_addr > filedata->file_size
5338 || dynamic_size > filedata->file_size - dynamic_addr)
5339 {
5340 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5341 dynamic_addr = dynamic_size = 0;
5342 }
5343 break;
5344
5345 case PT_INTERP:
5346 if (fseek (filedata->handle, archive_file_offset + (long) segment->p_offset,
5347 SEEK_SET))
5348 error (_("Unable to find program interpreter name\n"));
5349 else
5350 {
5351 char fmt [32];
5352 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
5353
5354 if (ret >= (int) sizeof (fmt) || ret < 0)
5355 error (_("Internal error: failed to create format string to display program interpreter\n"));
5356
5357 program_interpreter[0] = 0;
5358 if (fscanf (filedata->handle, fmt, program_interpreter) <= 0)
5359 error (_("Unable to read program interpreter name\n"));
5360
5361 if (do_segments)
5362 printf (_(" [Requesting program interpreter: %s]\n"),
5363 program_interpreter);
5364 }
5365 break;
5366 }
5367 }
5368
5369 if (do_segments
5370 && filedata->section_headers != NULL
5371 && filedata->string_table != NULL)
5372 {
5373 printf (_("\n Section to Segment mapping:\n"));
5374 printf (_(" Segment Sections...\n"));
5375
5376 for (i = 0; i < filedata->file_header.e_phnum; i++)
5377 {
5378 unsigned int j;
5379 Elf_Internal_Shdr * section;
5380
5381 segment = filedata->program_headers + i;
5382 section = filedata->section_headers + 1;
5383
5384 printf (" %2.2d ", i);
5385
5386 for (j = 1; j < filedata->file_header.e_shnum; j++, section++)
5387 {
5388 if (!ELF_TBSS_SPECIAL (section, segment)
5389 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
5390 printf ("%s ", printable_section_name (filedata, section));
5391 }
5392
5393 putc ('\n',stdout);
5394 }
5395 }
5396
5397 return TRUE;
5398 }
5399
5400
5401 /* Find the file offset corresponding to VMA by using the program headers. */
5402
5403 static long
offset_from_vma(Filedata * filedata,bfd_vma vma,bfd_size_type size)5404 offset_from_vma (Filedata * filedata, bfd_vma vma, bfd_size_type size)
5405 {
5406 Elf_Internal_Phdr * seg;
5407
5408 if (! get_program_headers (filedata))
5409 {
5410 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5411 return (long) vma;
5412 }
5413
5414 for (seg = filedata->program_headers;
5415 seg < filedata->program_headers + filedata->file_header.e_phnum;
5416 ++seg)
5417 {
5418 if (seg->p_type != PT_LOAD)
5419 continue;
5420
5421 if (vma >= (seg->p_vaddr & -seg->p_align)
5422 && vma + size <= seg->p_vaddr + seg->p_filesz)
5423 return vma - seg->p_vaddr + seg->p_offset;
5424 }
5425
5426 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5427 (unsigned long) vma);
5428 return (long) vma;
5429 }
5430
5431
5432 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5433 If PROBE is true, this is just a probe and we do not generate any error
5434 messages if the load fails. */
5435
5436 static bfd_boolean
get_32bit_section_headers(Filedata * filedata,bfd_boolean probe)5437 get_32bit_section_headers (Filedata * filedata, bfd_boolean probe)
5438 {
5439 Elf32_External_Shdr * shdrs;
5440 Elf_Internal_Shdr * internal;
5441 unsigned int i;
5442 unsigned int size = filedata->file_header.e_shentsize;
5443 unsigned int num = probe ? 1 : filedata->file_header.e_shnum;
5444
5445 /* PR binutils/17531: Cope with unexpected section header sizes. */
5446 if (size == 0 || num == 0)
5447 return FALSE;
5448 if (size < sizeof * shdrs)
5449 {
5450 if (! probe)
5451 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5452 return FALSE;
5453 }
5454 if (!probe && size > sizeof * shdrs)
5455 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5456
5457 shdrs = (Elf32_External_Shdr *) get_data (NULL, filedata, filedata->file_header.e_shoff,
5458 size, num,
5459 probe ? NULL : _("section headers"));
5460 if (shdrs == NULL)
5461 return FALSE;
5462
5463 free (filedata->section_headers);
5464 filedata->section_headers = (Elf_Internal_Shdr *)
5465 cmalloc (num, sizeof (Elf_Internal_Shdr));
5466 if (filedata->section_headers == NULL)
5467 {
5468 if (!probe)
5469 error (_("Out of memory reading %u section headers\n"), num);
5470 free (shdrs);
5471 return FALSE;
5472 }
5473
5474 for (i = 0, internal = filedata->section_headers;
5475 i < num;
5476 i++, internal++)
5477 {
5478 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5479 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
5480 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5481 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5482 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5483 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5484 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5485 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5486 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5487 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
5488 if (!probe && internal->sh_link > num)
5489 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5490 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5491 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5492 }
5493
5494 free (shdrs);
5495 return TRUE;
5496 }
5497
5498 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5499
5500 static bfd_boolean
get_64bit_section_headers(Filedata * filedata,bfd_boolean probe)5501 get_64bit_section_headers (Filedata * filedata, bfd_boolean probe)
5502 {
5503 Elf64_External_Shdr * shdrs;
5504 Elf_Internal_Shdr * internal;
5505 unsigned int i;
5506 unsigned int size = filedata->file_header.e_shentsize;
5507 unsigned int num = probe ? 1 : filedata->file_header.e_shnum;
5508
5509 /* PR binutils/17531: Cope with unexpected section header sizes. */
5510 if (size == 0 || num == 0)
5511 return FALSE;
5512
5513 if (size < sizeof * shdrs)
5514 {
5515 if (! probe)
5516 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5517 return FALSE;
5518 }
5519
5520 if (! probe && size > sizeof * shdrs)
5521 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5522
5523 shdrs = (Elf64_External_Shdr *) get_data (NULL, filedata,
5524 filedata->file_header.e_shoff,
5525 size, num,
5526 probe ? NULL : _("section headers"));
5527 if (shdrs == NULL)
5528 return FALSE;
5529
5530 free (filedata->section_headers);
5531 filedata->section_headers = (Elf_Internal_Shdr *)
5532 cmalloc (num, sizeof (Elf_Internal_Shdr));
5533 if (filedata->section_headers == NULL)
5534 {
5535 if (! probe)
5536 error (_("Out of memory reading %u section headers\n"), num);
5537 free (shdrs);
5538 return FALSE;
5539 }
5540
5541 for (i = 0, internal = filedata->section_headers;
5542 i < num;
5543 i++, internal++)
5544 {
5545 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5546 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
5547 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5548 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5549 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5550 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
5551 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5552 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5553 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5554 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5555 if (!probe && internal->sh_link > num)
5556 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5557 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5558 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5559 }
5560
5561 free (shdrs);
5562 return TRUE;
5563 }
5564
5565 static Elf_Internal_Sym *
get_32bit_elf_symbols(Filedata * filedata,Elf_Internal_Shdr * section,unsigned long * num_syms_return)5566 get_32bit_elf_symbols (Filedata * filedata,
5567 Elf_Internal_Shdr * section,
5568 unsigned long * num_syms_return)
5569 {
5570 unsigned long number = 0;
5571 Elf32_External_Sym * esyms = NULL;
5572 Elf_External_Sym_Shndx * shndx = NULL;
5573 Elf_Internal_Sym * isyms = NULL;
5574 Elf_Internal_Sym * psym;
5575 unsigned int j;
5576 elf_section_list * entry;
5577
5578 if (section->sh_size == 0)
5579 {
5580 if (num_syms_return != NULL)
5581 * num_syms_return = 0;
5582 return NULL;
5583 }
5584
5585 /* Run some sanity checks first. */
5586 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5587 {
5588 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5589 printable_section_name (filedata, section),
5590 (unsigned long) section->sh_entsize);
5591 goto exit_point;
5592 }
5593
5594 if (section->sh_size > filedata->file_size)
5595 {
5596 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5597 printable_section_name (filedata, section),
5598 (unsigned long) section->sh_size);
5599 goto exit_point;
5600 }
5601
5602 number = section->sh_size / section->sh_entsize;
5603
5604 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5605 {
5606 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5607 (unsigned long) section->sh_size,
5608 printable_section_name (filedata, section),
5609 (unsigned long) section->sh_entsize);
5610 goto exit_point;
5611 }
5612
5613 esyms = (Elf32_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5614 section->sh_size, _("symbols"));
5615 if (esyms == NULL)
5616 goto exit_point;
5617
5618 shndx = NULL;
5619 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5620 {
5621 if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5622 continue;
5623
5624 if (shndx != NULL)
5625 {
5626 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5627 free (shndx);
5628 }
5629
5630 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5631 entry->hdr->sh_offset,
5632 1, entry->hdr->sh_size,
5633 _("symbol table section indices"));
5634 if (shndx == NULL)
5635 goto exit_point;
5636
5637 /* PR17531: file: heap-buffer-overflow */
5638 if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5639 {
5640 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5641 printable_section_name (filedata, entry->hdr),
5642 (unsigned long) entry->hdr->sh_size,
5643 (unsigned long) section->sh_size);
5644 goto exit_point;
5645 }
5646 }
5647
5648 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5649
5650 if (isyms == NULL)
5651 {
5652 error (_("Out of memory reading %lu symbols\n"),
5653 (unsigned long) number);
5654 goto exit_point;
5655 }
5656
5657 for (j = 0, psym = isyms; j < number; j++, psym++)
5658 {
5659 psym->st_name = BYTE_GET (esyms[j].st_name);
5660 psym->st_value = BYTE_GET (esyms[j].st_value);
5661 psym->st_size = BYTE_GET (esyms[j].st_size);
5662 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5663 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5664 psym->st_shndx
5665 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5666 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5667 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5668 psym->st_info = BYTE_GET (esyms[j].st_info);
5669 psym->st_other = BYTE_GET (esyms[j].st_other);
5670 }
5671
5672 exit_point:
5673 free (shndx);
5674 free (esyms);
5675
5676 if (num_syms_return != NULL)
5677 * num_syms_return = isyms == NULL ? 0 : number;
5678
5679 return isyms;
5680 }
5681
5682 static Elf_Internal_Sym *
get_64bit_elf_symbols(Filedata * filedata,Elf_Internal_Shdr * section,unsigned long * num_syms_return)5683 get_64bit_elf_symbols (Filedata * filedata,
5684 Elf_Internal_Shdr * section,
5685 unsigned long * num_syms_return)
5686 {
5687 unsigned long number = 0;
5688 Elf64_External_Sym * esyms = NULL;
5689 Elf_External_Sym_Shndx * shndx = NULL;
5690 Elf_Internal_Sym * isyms = NULL;
5691 Elf_Internal_Sym * psym;
5692 unsigned int j;
5693 elf_section_list * entry;
5694
5695 if (section->sh_size == 0)
5696 {
5697 if (num_syms_return != NULL)
5698 * num_syms_return = 0;
5699 return NULL;
5700 }
5701
5702 /* Run some sanity checks first. */
5703 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5704 {
5705 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5706 printable_section_name (filedata, section),
5707 (unsigned long) section->sh_entsize);
5708 goto exit_point;
5709 }
5710
5711 if (section->sh_size > filedata->file_size)
5712 {
5713 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5714 printable_section_name (filedata, section),
5715 (unsigned long) section->sh_size);
5716 goto exit_point;
5717 }
5718
5719 number = section->sh_size / section->sh_entsize;
5720
5721 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5722 {
5723 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5724 (unsigned long) section->sh_size,
5725 printable_section_name (filedata, section),
5726 (unsigned long) section->sh_entsize);
5727 goto exit_point;
5728 }
5729
5730 esyms = (Elf64_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5731 section->sh_size, _("symbols"));
5732 if (!esyms)
5733 goto exit_point;
5734
5735 shndx = NULL;
5736 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5737 {
5738 if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5739 continue;
5740
5741 if (shndx != NULL)
5742 {
5743 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5744 free (shndx);
5745 }
5746
5747 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5748 entry->hdr->sh_offset,
5749 1, entry->hdr->sh_size,
5750 _("symbol table section indices"));
5751 if (shndx == NULL)
5752 goto exit_point;
5753
5754 /* PR17531: file: heap-buffer-overflow */
5755 if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5756 {
5757 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5758 printable_section_name (filedata, entry->hdr),
5759 (unsigned long) entry->hdr->sh_size,
5760 (unsigned long) section->sh_size);
5761 goto exit_point;
5762 }
5763 }
5764
5765 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5766
5767 if (isyms == NULL)
5768 {
5769 error (_("Out of memory reading %lu symbols\n"),
5770 (unsigned long) number);
5771 goto exit_point;
5772 }
5773
5774 for (j = 0, psym = isyms; j < number; j++, psym++)
5775 {
5776 psym->st_name = BYTE_GET (esyms[j].st_name);
5777 psym->st_info = BYTE_GET (esyms[j].st_info);
5778 psym->st_other = BYTE_GET (esyms[j].st_other);
5779 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5780
5781 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5782 psym->st_shndx
5783 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5784 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5785 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5786
5787 psym->st_value = BYTE_GET (esyms[j].st_value);
5788 psym->st_size = BYTE_GET (esyms[j].st_size);
5789 }
5790
5791 exit_point:
5792 free (shndx);
5793 free (esyms);
5794
5795 if (num_syms_return != NULL)
5796 * num_syms_return = isyms == NULL ? 0 : number;
5797
5798 return isyms;
5799 }
5800
5801 static const char *
get_elf_section_flags(Filedata * filedata,bfd_vma sh_flags)5802 get_elf_section_flags (Filedata * filedata, bfd_vma sh_flags)
5803 {
5804 static char buff[1024];
5805 char * p = buff;
5806 unsigned int field_size = is_32bit_elf ? 8 : 16;
5807 signed int sindex;
5808 unsigned int size = sizeof (buff) - (field_size + 4 + 1);
5809 bfd_vma os_flags = 0;
5810 bfd_vma proc_flags = 0;
5811 bfd_vma unknown_flags = 0;
5812 static const struct
5813 {
5814 const char * str;
5815 unsigned int len;
5816 }
5817 flags [] =
5818 {
5819 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5820 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5821 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5822 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5823 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5824 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5825 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5826 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5827 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5828 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5829 /* IA-64 specific. */
5830 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5831 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5832 /* IA-64 OpenVMS specific. */
5833 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5834 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5835 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5836 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5837 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5838 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5839 /* Generic. */
5840 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5841 /* SPARC specific. */
5842 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5843 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5844 /* ARM specific. */
5845 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5846 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5847 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5848 /* GNU specific. */
5849 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5850 /* VLE specific. */
5851 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5852 };
5853
5854 if (do_section_details)
5855 {
5856 sprintf (buff, "[%*.*lx]: ",
5857 field_size, field_size, (unsigned long) sh_flags);
5858 p += field_size + 4;
5859 }
5860
5861 while (sh_flags)
5862 {
5863 bfd_vma flag;
5864
5865 flag = sh_flags & - sh_flags;
5866 sh_flags &= ~ flag;
5867
5868 if (do_section_details)
5869 {
5870 switch (flag)
5871 {
5872 case SHF_WRITE: sindex = 0; break;
5873 case SHF_ALLOC: sindex = 1; break;
5874 case SHF_EXECINSTR: sindex = 2; break;
5875 case SHF_MERGE: sindex = 3; break;
5876 case SHF_STRINGS: sindex = 4; break;
5877 case SHF_INFO_LINK: sindex = 5; break;
5878 case SHF_LINK_ORDER: sindex = 6; break;
5879 case SHF_OS_NONCONFORMING: sindex = 7; break;
5880 case SHF_GROUP: sindex = 8; break;
5881 case SHF_TLS: sindex = 9; break;
5882 case SHF_EXCLUDE: sindex = 18; break;
5883 case SHF_COMPRESSED: sindex = 20; break;
5884 case SHF_GNU_MBIND: sindex = 24; break;
5885
5886 default:
5887 sindex = -1;
5888 switch (filedata->file_header.e_machine)
5889 {
5890 case EM_IA_64:
5891 if (flag == SHF_IA_64_SHORT)
5892 sindex = 10;
5893 else if (flag == SHF_IA_64_NORECOV)
5894 sindex = 11;
5895 #ifdef BFD64
5896 else if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5897 switch (flag)
5898 {
5899 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5900 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5901 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5902 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5903 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5904 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
5905 default: break;
5906 }
5907 #endif
5908 break;
5909
5910 case EM_386:
5911 case EM_IAMCU:
5912 case EM_X86_64:
5913 case EM_L1OM:
5914 case EM_K1OM:
5915 case EM_OLD_SPARCV9:
5916 case EM_SPARC32PLUS:
5917 case EM_SPARCV9:
5918 case EM_SPARC:
5919 if (flag == SHF_ORDERED)
5920 sindex = 19;
5921 break;
5922
5923 case EM_ARM:
5924 switch (flag)
5925 {
5926 case SHF_ENTRYSECT: sindex = 21; break;
5927 case SHF_ARM_PURECODE: sindex = 22; break;
5928 case SHF_COMDEF: sindex = 23; break;
5929 default: break;
5930 }
5931 break;
5932 case EM_PPC:
5933 if (flag == SHF_PPC_VLE)
5934 sindex = 25;
5935 break;
5936
5937 default:
5938 break;
5939 }
5940 }
5941
5942 if (sindex != -1)
5943 {
5944 if (p != buff + field_size + 4)
5945 {
5946 if (size < (10 + 2))
5947 {
5948 warn (_("Internal error: not enough buffer room for section flag info"));
5949 return _("<unknown>");
5950 }
5951 size -= 2;
5952 *p++ = ',';
5953 *p++ = ' ';
5954 }
5955
5956 size -= flags [sindex].len;
5957 p = stpcpy (p, flags [sindex].str);
5958 }
5959 else if (flag & SHF_MASKOS)
5960 os_flags |= flag;
5961 else if (flag & SHF_MASKPROC)
5962 proc_flags |= flag;
5963 else
5964 unknown_flags |= flag;
5965 }
5966 else
5967 {
5968 switch (flag)
5969 {
5970 case SHF_WRITE: *p = 'W'; break;
5971 case SHF_ALLOC: *p = 'A'; break;
5972 case SHF_EXECINSTR: *p = 'X'; break;
5973 case SHF_MERGE: *p = 'M'; break;
5974 case SHF_STRINGS: *p = 'S'; break;
5975 case SHF_INFO_LINK: *p = 'I'; break;
5976 case SHF_LINK_ORDER: *p = 'L'; break;
5977 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5978 case SHF_GROUP: *p = 'G'; break;
5979 case SHF_TLS: *p = 'T'; break;
5980 case SHF_EXCLUDE: *p = 'E'; break;
5981 case SHF_COMPRESSED: *p = 'C'; break;
5982 case SHF_GNU_MBIND: *p = 'D'; break;
5983
5984 default:
5985 if ((filedata->file_header.e_machine == EM_X86_64
5986 || filedata->file_header.e_machine == EM_L1OM
5987 || filedata->file_header.e_machine == EM_K1OM)
5988 && flag == SHF_X86_64_LARGE)
5989 *p = 'l';
5990 else if (filedata->file_header.e_machine == EM_ARM
5991 && flag == SHF_ARM_PURECODE)
5992 *p = 'y';
5993 else if (filedata->file_header.e_machine == EM_PPC
5994 && flag == SHF_PPC_VLE)
5995 *p = 'v';
5996 else if (flag & SHF_MASKOS)
5997 {
5998 *p = 'o';
5999 sh_flags &= ~ SHF_MASKOS;
6000 }
6001 else if (flag & SHF_MASKPROC)
6002 {
6003 *p = 'p';
6004 sh_flags &= ~ SHF_MASKPROC;
6005 }
6006 else
6007 *p = 'x';
6008 break;
6009 }
6010 p++;
6011 }
6012 }
6013
6014 if (do_section_details)
6015 {
6016 if (os_flags)
6017 {
6018 size -= 5 + field_size;
6019 if (p != buff + field_size + 4)
6020 {
6021 if (size < (2 + 1))
6022 {
6023 warn (_("Internal error: not enough buffer room for section flag info"));
6024 return _("<unknown>");
6025 }
6026 size -= 2;
6027 *p++ = ',';
6028 *p++ = ' ';
6029 }
6030 sprintf (p, "OS (%*.*lx)", field_size, field_size,
6031 (unsigned long) os_flags);
6032 p += 5 + field_size;
6033 }
6034 if (proc_flags)
6035 {
6036 size -= 7 + field_size;
6037 if (p != buff + field_size + 4)
6038 {
6039 if (size < (2 + 1))
6040 {
6041 warn (_("Internal error: not enough buffer room for section flag info"));
6042 return _("<unknown>");
6043 }
6044 size -= 2;
6045 *p++ = ',';
6046 *p++ = ' ';
6047 }
6048 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
6049 (unsigned long) proc_flags);
6050 p += 7 + field_size;
6051 }
6052 if (unknown_flags)
6053 {
6054 size -= 10 + field_size;
6055 if (p != buff + field_size + 4)
6056 {
6057 if (size < (2 + 1))
6058 {
6059 warn (_("Internal error: not enough buffer room for section flag info"));
6060 return _("<unknown>");
6061 }
6062 size -= 2;
6063 *p++ = ',';
6064 *p++ = ' ';
6065 }
6066 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
6067 (unsigned long) unknown_flags);
6068 p += 10 + field_size;
6069 }
6070 }
6071
6072 *p = '\0';
6073 return buff;
6074 }
6075
6076 static unsigned int
get_compression_header(Elf_Internal_Chdr * chdr,unsigned char * buf,bfd_size_type size)6077 get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
6078 {
6079 if (is_32bit_elf)
6080 {
6081 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
6082
6083 if (size < sizeof (* echdr))
6084 {
6085 error (_("Compressed section is too small even for a compression header\n"));
6086 return 0;
6087 }
6088
6089 chdr->ch_type = BYTE_GET (echdr->ch_type);
6090 chdr->ch_size = BYTE_GET (echdr->ch_size);
6091 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
6092 return sizeof (*echdr);
6093 }
6094 else
6095 {
6096 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
6097
6098 if (size < sizeof (* echdr))
6099 {
6100 error (_("Compressed section is too small even for a compression header\n"));
6101 return 0;
6102 }
6103
6104 chdr->ch_type = BYTE_GET (echdr->ch_type);
6105 chdr->ch_size = BYTE_GET (echdr->ch_size);
6106 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
6107 return sizeof (*echdr);
6108 }
6109 }
6110
6111 static bfd_boolean
process_section_headers(Filedata * filedata)6112 process_section_headers (Filedata * filedata)
6113 {
6114 Elf_Internal_Shdr * section;
6115 unsigned int i;
6116
6117 filedata->section_headers = NULL;
6118
6119 if (filedata->file_header.e_shnum == 0)
6120 {
6121 /* PR binutils/12467. */
6122 if (filedata->file_header.e_shoff != 0)
6123 {
6124 warn (_("possibly corrupt ELF file header - it has a non-zero"
6125 " section header offset, but no section headers\n"));
6126 return FALSE;
6127 }
6128 else if (do_sections)
6129 printf (_("\nThere are no sections in this file.\n"));
6130
6131 return TRUE;
6132 }
6133
6134 if (do_sections && !do_header)
6135 printf (ngettext ("There is %d section header, "
6136 "starting at offset 0x%lx:\n",
6137 "There are %d section headers, "
6138 "starting at offset 0x%lx:\n",
6139 filedata->file_header.e_shnum),
6140 filedata->file_header.e_shnum,
6141 (unsigned long) filedata->file_header.e_shoff);
6142
6143 if (is_32bit_elf)
6144 {
6145 if (! get_32bit_section_headers (filedata, FALSE))
6146 return FALSE;
6147 }
6148 else
6149 {
6150 if (! get_64bit_section_headers (filedata, FALSE))
6151 return FALSE;
6152 }
6153
6154 /* Read in the string table, so that we have names to display. */
6155 if (filedata->file_header.e_shstrndx != SHN_UNDEF
6156 && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
6157 {
6158 section = filedata->section_headers + filedata->file_header.e_shstrndx;
6159
6160 if (section->sh_size != 0)
6161 {
6162 filedata->string_table = (char *) get_data (NULL, filedata, section->sh_offset,
6163 1, section->sh_size,
6164 _("string table"));
6165
6166 filedata->string_table_length = filedata->string_table != NULL ? section->sh_size : 0;
6167 }
6168 }
6169
6170 /* Scan the sections for the dynamic symbol table
6171 and dynamic string table and debug sections. */
6172 dynamic_symbols = NULL;
6173 dynamic_strings = NULL;
6174 dynamic_syminfo = NULL;
6175 symtab_shndx_list = NULL;
6176
6177 eh_addr_size = is_32bit_elf ? 4 : 8;
6178 switch (filedata->file_header.e_machine)
6179 {
6180 case EM_MIPS:
6181 case EM_MIPS_RS3_LE:
6182 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6183 FDE addresses. However, the ABI also has a semi-official ILP32
6184 variant for which the normal FDE address size rules apply.
6185
6186 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6187 section, where XX is the size of longs in bits. Unfortunately,
6188 earlier compilers provided no way of distinguishing ILP32 objects
6189 from LP64 objects, so if there's any doubt, we should assume that
6190 the official LP64 form is being used. */
6191 if ((filedata->file_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
6192 && find_section (filedata, ".gcc_compiled_long32") == NULL)
6193 eh_addr_size = 8;
6194 break;
6195
6196 case EM_H8_300:
6197 case EM_H8_300H:
6198 switch (filedata->file_header.e_flags & EF_H8_MACH)
6199 {
6200 case E_H8_MACH_H8300:
6201 case E_H8_MACH_H8300HN:
6202 case E_H8_MACH_H8300SN:
6203 case E_H8_MACH_H8300SXN:
6204 eh_addr_size = 2;
6205 break;
6206 case E_H8_MACH_H8300H:
6207 case E_H8_MACH_H8300S:
6208 case E_H8_MACH_H8300SX:
6209 eh_addr_size = 4;
6210 break;
6211 }
6212 break;
6213
6214 case EM_M32C_OLD:
6215 case EM_M32C:
6216 switch (filedata->file_header.e_flags & EF_M32C_CPU_MASK)
6217 {
6218 case EF_M32C_CPU_M16C:
6219 eh_addr_size = 2;
6220 break;
6221 }
6222 break;
6223 }
6224
6225 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6226 do \
6227 { \
6228 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6229 if (section->sh_entsize != expected_entsize) \
6230 { \
6231 char buf[40]; \
6232 sprintf_vma (buf, section->sh_entsize); \
6233 /* Note: coded this way so that there is a single string for \
6234 translation. */ \
6235 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6236 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6237 (unsigned) expected_entsize); \
6238 section->sh_entsize = expected_entsize; \
6239 } \
6240 } \
6241 while (0)
6242
6243 #define CHECK_ENTSIZE(section, i, type) \
6244 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6245 sizeof (Elf64_External_##type))
6246
6247 for (i = 0, section = filedata->section_headers;
6248 i < filedata->file_header.e_shnum;
6249 i++, section++)
6250 {
6251 char * name = SECTION_NAME (section);
6252
6253 if (section->sh_type == SHT_DYNSYM)
6254 {
6255 if (dynamic_symbols != NULL)
6256 {
6257 error (_("File contains multiple dynamic symbol tables\n"));
6258 continue;
6259 }
6260
6261 CHECK_ENTSIZE (section, i, Sym);
6262 dynamic_symbols = GET_ELF_SYMBOLS (filedata, section, & num_dynamic_syms);
6263 }
6264 else if (section->sh_type == SHT_STRTAB
6265 && streq (name, ".dynstr"))
6266 {
6267 if (dynamic_strings != NULL)
6268 {
6269 error (_("File contains multiple dynamic string tables\n"));
6270 continue;
6271 }
6272
6273 dynamic_strings = (char *) get_data (NULL, filedata, section->sh_offset,
6274 1, section->sh_size,
6275 _("dynamic strings"));
6276 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
6277 }
6278 else if (section->sh_type == SHT_SYMTAB_SHNDX)
6279 {
6280 elf_section_list * entry = xmalloc (sizeof * entry);
6281
6282 entry->hdr = section;
6283 entry->next = symtab_shndx_list;
6284 symtab_shndx_list = entry;
6285 }
6286 else if (section->sh_type == SHT_SYMTAB)
6287 CHECK_ENTSIZE (section, i, Sym);
6288 else if (section->sh_type == SHT_GROUP)
6289 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
6290 else if (section->sh_type == SHT_REL)
6291 CHECK_ENTSIZE (section, i, Rel);
6292 else if (section->sh_type == SHT_RELA)
6293 CHECK_ENTSIZE (section, i, Rela);
6294 else if ((do_debugging || do_debug_info || do_debug_abbrevs
6295 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
6296 || do_debug_aranges || do_debug_frames || do_debug_macinfo
6297 || do_debug_str || do_debug_loc || do_debug_ranges
6298 || do_debug_addr || do_debug_cu_index || do_debug_links)
6299 && (const_strneq (name, ".debug_")
6300 || const_strneq (name, ".zdebug_")))
6301 {
6302 if (name[1] == 'z')
6303 name += sizeof (".zdebug_") - 1;
6304 else
6305 name += sizeof (".debug_") - 1;
6306
6307 if (do_debugging
6308 || (do_debug_info && const_strneq (name, "info"))
6309 || (do_debug_info && const_strneq (name, "types"))
6310 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
6311 || (do_debug_lines && strcmp (name, "line") == 0)
6312 || (do_debug_lines && const_strneq (name, "line."))
6313 || (do_debug_pubnames && const_strneq (name, "pubnames"))
6314 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
6315 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
6316 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
6317 || (do_debug_aranges && const_strneq (name, "aranges"))
6318 || (do_debug_ranges && const_strneq (name, "ranges"))
6319 || (do_debug_ranges && const_strneq (name, "rnglists"))
6320 || (do_debug_frames && const_strneq (name, "frame"))
6321 || (do_debug_macinfo && const_strneq (name, "macinfo"))
6322 || (do_debug_macinfo && const_strneq (name, "macro"))
6323 || (do_debug_str && const_strneq (name, "str"))
6324 || (do_debug_loc && const_strneq (name, "loc"))
6325 || (do_debug_loc && const_strneq (name, "loclists"))
6326 || (do_debug_addr && const_strneq (name, "addr"))
6327 || (do_debug_cu_index && const_strneq (name, "cu_index"))
6328 || (do_debug_cu_index && const_strneq (name, "tu_index"))
6329 )
6330 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6331 }
6332 /* Linkonce section to be combined with .debug_info at link time. */
6333 else if ((do_debugging || do_debug_info)
6334 && const_strneq (name, ".gnu.linkonce.wi."))
6335 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6336 else if (do_debug_frames && streq (name, ".eh_frame"))
6337 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6338 else if (do_gdb_index && (streq (name, ".gdb_index")
6339 || streq (name, ".debug_names")))
6340 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6341 /* Trace sections for Itanium VMS. */
6342 else if ((do_debugging || do_trace_info || do_trace_abbrevs
6343 || do_trace_aranges)
6344 && const_strneq (name, ".trace_"))
6345 {
6346 name += sizeof (".trace_") - 1;
6347
6348 if (do_debugging
6349 || (do_trace_info && streq (name, "info"))
6350 || (do_trace_abbrevs && streq (name, "abbrev"))
6351 || (do_trace_aranges && streq (name, "aranges"))
6352 )
6353 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6354 }
6355 else if ((do_debugging || do_debug_links)
6356 && (const_strneq (name, ".gnu_debuglink")
6357 || const_strneq (name, ".gnu_debugaltlink")))
6358 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6359 }
6360
6361 if (! do_sections)
6362 return TRUE;
6363
6364 if (filedata->file_header.e_shnum > 1)
6365 printf (_("\nSection Headers:\n"));
6366 else
6367 printf (_("\nSection Header:\n"));
6368
6369 if (is_32bit_elf)
6370 {
6371 if (do_section_details)
6372 {
6373 printf (_(" [Nr] Name\n"));
6374 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6375 }
6376 else
6377 printf
6378 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6379 }
6380 else if (do_wide)
6381 {
6382 if (do_section_details)
6383 {
6384 printf (_(" [Nr] Name\n"));
6385 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6386 }
6387 else
6388 printf
6389 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6390 }
6391 else
6392 {
6393 if (do_section_details)
6394 {
6395 printf (_(" [Nr] Name\n"));
6396 printf (_(" Type Address Offset Link\n"));
6397 printf (_(" Size EntSize Info Align\n"));
6398 }
6399 else
6400 {
6401 printf (_(" [Nr] Name Type Address Offset\n"));
6402 printf (_(" Size EntSize Flags Link Info Align\n"));
6403 }
6404 }
6405
6406 if (do_section_details)
6407 printf (_(" Flags\n"));
6408
6409 for (i = 0, section = filedata->section_headers;
6410 i < filedata->file_header.e_shnum;
6411 i++, section++)
6412 {
6413 /* Run some sanity checks on the section header. */
6414
6415 /* Check the sh_link field. */
6416 switch (section->sh_type)
6417 {
6418 case SHT_REL:
6419 case SHT_RELA:
6420 if (section->sh_link == 0
6421 && (filedata->file_header.e_type == ET_EXEC
6422 || filedata->file_header.e_type == ET_DYN))
6423 /* A dynamic relocation section where all entries use a
6424 zero symbol index need not specify a symtab section. */
6425 break;
6426 /* Fall through. */
6427 case SHT_SYMTAB_SHNDX:
6428 case SHT_GROUP:
6429 case SHT_HASH:
6430 case SHT_GNU_HASH:
6431 case SHT_GNU_versym:
6432 if (section->sh_link == 0
6433 || section->sh_link >= filedata->file_header.e_shnum
6434 || (filedata->section_headers[section->sh_link].sh_type != SHT_SYMTAB
6435 && filedata->section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6436 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6437 i, section->sh_link);
6438 break;
6439
6440 case SHT_DYNAMIC:
6441 case SHT_SYMTAB:
6442 case SHT_DYNSYM:
6443 case SHT_GNU_verneed:
6444 case SHT_GNU_verdef:
6445 case SHT_GNU_LIBLIST:
6446 if (section->sh_link == 0
6447 || section->sh_link >= filedata->file_header.e_shnum
6448 || filedata->section_headers[section->sh_link].sh_type != SHT_STRTAB)
6449 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6450 i, section->sh_link);
6451 break;
6452
6453 case SHT_INIT_ARRAY:
6454 case SHT_FINI_ARRAY:
6455 case SHT_PREINIT_ARRAY:
6456 if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6457 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6458 i, section->sh_link);
6459 break;
6460
6461 default:
6462 /* FIXME: Add support for target specific section types. */
6463 #if 0 /* Currently we do not check other section types as there are too
6464 many special cases. Stab sections for example have a type
6465 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6466 section. */
6467 if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6468 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6469 i, section->sh_link);
6470 #endif
6471 break;
6472 }
6473
6474 /* Check the sh_info field. */
6475 switch (section->sh_type)
6476 {
6477 case SHT_REL:
6478 case SHT_RELA:
6479 if (section->sh_info == 0
6480 && (filedata->file_header.e_type == ET_EXEC
6481 || filedata->file_header.e_type == ET_DYN))
6482 /* Dynamic relocations apply to segments, so they do not
6483 need to specify the section they relocate. */
6484 break;
6485 if (section->sh_info == 0
6486 || section->sh_info >= filedata->file_header.e_shnum
6487 || (filedata->section_headers[section->sh_info].sh_type != SHT_PROGBITS
6488 && filedata->section_headers[section->sh_info].sh_type != SHT_NOBITS
6489 && filedata->section_headers[section->sh_info].sh_type != SHT_NOTE
6490 && filedata->section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6491 && filedata->section_headers[section->sh_info].sh_type != SHT_FINI_ARRAY
6492 && filedata->section_headers[section->sh_info].sh_type != SHT_PREINIT_ARRAY
6493 /* FIXME: Are other section types valid ? */
6494 && filedata->section_headers[section->sh_info].sh_type < SHT_LOOS))
6495 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6496 i, section->sh_info);
6497 break;
6498
6499 case SHT_DYNAMIC:
6500 case SHT_HASH:
6501 case SHT_SYMTAB_SHNDX:
6502 case SHT_INIT_ARRAY:
6503 case SHT_FINI_ARRAY:
6504 case SHT_PREINIT_ARRAY:
6505 if (section->sh_info != 0)
6506 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6507 i, section->sh_info);
6508 break;
6509
6510 case SHT_GROUP:
6511 case SHT_SYMTAB:
6512 case SHT_DYNSYM:
6513 /* A symbol index - we assume that it is valid. */
6514 break;
6515
6516 default:
6517 /* FIXME: Add support for target specific section types. */
6518 if (section->sh_type == SHT_NOBITS)
6519 /* NOBITS section headers with non-zero sh_info fields can be
6520 created when a binary is stripped of everything but its debug
6521 information. The stripped sections have their headers
6522 preserved but their types set to SHT_NOBITS. So do not check
6523 this type of section. */
6524 ;
6525 else if (section->sh_flags & SHF_INFO_LINK)
6526 {
6527 if (section->sh_info < 1 || section->sh_info >= filedata->file_header.e_shnum)
6528 warn (_("[%2u]: Expected link to another section in info field"), i);
6529 }
6530 else if (section->sh_type < SHT_LOOS
6531 && (section->sh_flags & SHF_GNU_MBIND) == 0
6532 && section->sh_info != 0)
6533 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6534 i, section->sh_info);
6535 break;
6536 }
6537
6538 /* Check the sh_size field. */
6539 if (section->sh_size > filedata->file_size
6540 && section->sh_type != SHT_NOBITS
6541 && section->sh_type != SHT_NULL
6542 && section->sh_type < SHT_LOOS)
6543 warn (_("Size of section %u is larger than the entire file!\n"), i);
6544
6545 printf (" [%2u] ", i);
6546 if (do_section_details)
6547 printf ("%s\n ", printable_section_name (filedata, section));
6548 else
6549 print_symbol (-17, SECTION_NAME (section));
6550
6551 printf (do_wide ? " %-15s " : " %-15.15s ",
6552 get_section_type_name (filedata, section->sh_type));
6553
6554 if (is_32bit_elf)
6555 {
6556 const char * link_too_big = NULL;
6557
6558 print_vma (section->sh_addr, LONG_HEX);
6559
6560 printf ( " %6.6lx %6.6lx %2.2lx",
6561 (unsigned long) section->sh_offset,
6562 (unsigned long) section->sh_size,
6563 (unsigned long) section->sh_entsize);
6564
6565 if (do_section_details)
6566 fputs (" ", stdout);
6567 else
6568 printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6569
6570 if (section->sh_link >= filedata->file_header.e_shnum)
6571 {
6572 link_too_big = "";
6573 /* The sh_link value is out of range. Normally this indicates
6574 an error but it can have special values in Solaris binaries. */
6575 switch (filedata->file_header.e_machine)
6576 {
6577 case EM_386:
6578 case EM_IAMCU:
6579 case EM_X86_64:
6580 case EM_L1OM:
6581 case EM_K1OM:
6582 case EM_OLD_SPARCV9:
6583 case EM_SPARC32PLUS:
6584 case EM_SPARCV9:
6585 case EM_SPARC:
6586 if (section->sh_link == (SHN_BEFORE & 0xffff))
6587 link_too_big = "BEFORE";
6588 else if (section->sh_link == (SHN_AFTER & 0xffff))
6589 link_too_big = "AFTER";
6590 break;
6591 default:
6592 break;
6593 }
6594 }
6595
6596 if (do_section_details)
6597 {
6598 if (link_too_big != NULL && * link_too_big)
6599 printf ("<%s> ", link_too_big);
6600 else
6601 printf ("%2u ", section->sh_link);
6602 printf ("%3u %2lu\n", section->sh_info,
6603 (unsigned long) section->sh_addralign);
6604 }
6605 else
6606 printf ("%2u %3u %2lu\n",
6607 section->sh_link,
6608 section->sh_info,
6609 (unsigned long) section->sh_addralign);
6610
6611 if (link_too_big && ! * link_too_big)
6612 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6613 i, section->sh_link);
6614 }
6615 else if (do_wide)
6616 {
6617 print_vma (section->sh_addr, LONG_HEX);
6618
6619 if ((long) section->sh_offset == section->sh_offset)
6620 printf (" %6.6lx", (unsigned long) section->sh_offset);
6621 else
6622 {
6623 putchar (' ');
6624 print_vma (section->sh_offset, LONG_HEX);
6625 }
6626
6627 if ((unsigned long) section->sh_size == section->sh_size)
6628 printf (" %6.6lx", (unsigned long) section->sh_size);
6629 else
6630 {
6631 putchar (' ');
6632 print_vma (section->sh_size, LONG_HEX);
6633 }
6634
6635 if ((unsigned long) section->sh_entsize == section->sh_entsize)
6636 printf (" %2.2lx", (unsigned long) section->sh_entsize);
6637 else
6638 {
6639 putchar (' ');
6640 print_vma (section->sh_entsize, LONG_HEX);
6641 }
6642
6643 if (do_section_details)
6644 fputs (" ", stdout);
6645 else
6646 printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6647
6648 printf ("%2u %3u ", section->sh_link, section->sh_info);
6649
6650 if ((unsigned long) section->sh_addralign == section->sh_addralign)
6651 printf ("%2lu\n", (unsigned long) section->sh_addralign);
6652 else
6653 {
6654 print_vma (section->sh_addralign, DEC);
6655 putchar ('\n');
6656 }
6657 }
6658 else if (do_section_details)
6659 {
6660 putchar (' ');
6661 print_vma (section->sh_addr, LONG_HEX);
6662 if ((long) section->sh_offset == section->sh_offset)
6663 printf (" %16.16lx", (unsigned long) section->sh_offset);
6664 else
6665 {
6666 printf (" ");
6667 print_vma (section->sh_offset, LONG_HEX);
6668 }
6669 printf (" %u\n ", section->sh_link);
6670 print_vma (section->sh_size, LONG_HEX);
6671 putchar (' ');
6672 print_vma (section->sh_entsize, LONG_HEX);
6673
6674 printf (" %-16u %lu\n",
6675 section->sh_info,
6676 (unsigned long) section->sh_addralign);
6677 }
6678 else
6679 {
6680 putchar (' ');
6681 print_vma (section->sh_addr, LONG_HEX);
6682 if ((long) section->sh_offset == section->sh_offset)
6683 printf (" %8.8lx", (unsigned long) section->sh_offset);
6684 else
6685 {
6686 printf (" ");
6687 print_vma (section->sh_offset, LONG_HEX);
6688 }
6689 printf ("\n ");
6690 print_vma (section->sh_size, LONG_HEX);
6691 printf (" ");
6692 print_vma (section->sh_entsize, LONG_HEX);
6693
6694 printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6695
6696 printf (" %2u %3u %lu\n",
6697 section->sh_link,
6698 section->sh_info,
6699 (unsigned long) section->sh_addralign);
6700 }
6701
6702 if (do_section_details)
6703 {
6704 printf (" %s\n", get_elf_section_flags (filedata, section->sh_flags));
6705 if ((section->sh_flags & SHF_COMPRESSED) != 0)
6706 {
6707 /* Minimum section size is 12 bytes for 32-bit compression
6708 header + 12 bytes for compressed data header. */
6709 unsigned char buf[24];
6710
6711 assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6712 if (get_data (&buf, filedata, section->sh_offset, 1,
6713 sizeof (buf), _("compression header")))
6714 {
6715 Elf_Internal_Chdr chdr;
6716
6717 (void) get_compression_header (&chdr, buf, sizeof (buf));
6718
6719 if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6720 printf (" ZLIB, ");
6721 else
6722 printf (_(" [<unknown>: 0x%x], "),
6723 chdr.ch_type);
6724 print_vma (chdr.ch_size, LONG_HEX);
6725 printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6726 }
6727 }
6728 }
6729 }
6730
6731 if (!do_section_details)
6732 {
6733 /* The ordering of the letters shown here matches the ordering of the
6734 corresponding SHF_xxx values, and hence the order in which these
6735 letters will be displayed to the user. */
6736 printf (_("Key to Flags:\n\
6737 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6738 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6739 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6740 if (filedata->file_header.e_machine == EM_X86_64
6741 || filedata->file_header.e_machine == EM_L1OM
6742 || filedata->file_header.e_machine == EM_K1OM)
6743 printf (_("l (large), "));
6744 else if (filedata->file_header.e_machine == EM_ARM)
6745 printf (_("y (purecode), "));
6746 else if (filedata->file_header.e_machine == EM_PPC)
6747 printf (_("v (VLE), "));
6748 printf ("p (processor specific)\n");
6749 }
6750
6751 return TRUE;
6752 }
6753
6754 static const char *
get_group_flags(unsigned int flags)6755 get_group_flags (unsigned int flags)
6756 {
6757 static char buff[128];
6758
6759 if (flags == 0)
6760 return "";
6761 else if (flags == GRP_COMDAT)
6762 return "COMDAT ";
6763
6764 snprintf (buff, 14, _("[0x%x: "), flags);
6765
6766 flags &= ~ GRP_COMDAT;
6767 if (flags & GRP_MASKOS)
6768 {
6769 strcat (buff, "<OS specific>");
6770 flags &= ~ GRP_MASKOS;
6771 }
6772
6773 if (flags & GRP_MASKPROC)
6774 {
6775 strcat (buff, "<PROC specific>");
6776 flags &= ~ GRP_MASKPROC;
6777 }
6778
6779 if (flags)
6780 strcat (buff, "<unknown>");
6781
6782 strcat (buff, "]");
6783 return buff;
6784 }
6785
6786 static bfd_boolean
process_section_groups(Filedata * filedata)6787 process_section_groups (Filedata * filedata)
6788 {
6789 Elf_Internal_Shdr * section;
6790 unsigned int i;
6791 struct group * group;
6792 Elf_Internal_Shdr * symtab_sec;
6793 Elf_Internal_Shdr * strtab_sec;
6794 Elf_Internal_Sym * symtab;
6795 unsigned long num_syms;
6796 char * strtab;
6797 size_t strtab_size;
6798
6799 /* Don't process section groups unless needed. */
6800 if (!do_unwind && !do_section_groups)
6801 return TRUE;
6802
6803 if (filedata->file_header.e_shnum == 0)
6804 {
6805 if (do_section_groups)
6806 printf (_("\nThere are no sections to group in this file.\n"));
6807
6808 return TRUE;
6809 }
6810
6811 if (filedata->section_headers == NULL)
6812 {
6813 error (_("Section headers are not available!\n"));
6814 /* PR 13622: This can happen with a corrupt ELF header. */
6815 return FALSE;
6816 }
6817
6818 section_headers_groups = (struct group **) calloc (filedata->file_header.e_shnum,
6819 sizeof (struct group *));
6820
6821 if (section_headers_groups == NULL)
6822 {
6823 error (_("Out of memory reading %u section group headers\n"),
6824 filedata->file_header.e_shnum);
6825 return FALSE;
6826 }
6827
6828 /* Scan the sections for the group section. */
6829 group_count = 0;
6830 for (i = 0, section = filedata->section_headers;
6831 i < filedata->file_header.e_shnum;
6832 i++, section++)
6833 if (section->sh_type == SHT_GROUP)
6834 group_count++;
6835
6836 if (group_count == 0)
6837 {
6838 if (do_section_groups)
6839 printf (_("\nThere are no section groups in this file.\n"));
6840
6841 return TRUE;
6842 }
6843
6844 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6845
6846 if (section_groups == NULL)
6847 {
6848 error (_("Out of memory reading %lu groups\n"),
6849 (unsigned long) group_count);
6850 return FALSE;
6851 }
6852
6853 symtab_sec = NULL;
6854 strtab_sec = NULL;
6855 symtab = NULL;
6856 num_syms = 0;
6857 strtab = NULL;
6858 strtab_size = 0;
6859 for (i = 0, section = filedata->section_headers, group = section_groups;
6860 i < filedata->file_header.e_shnum;
6861 i++, section++)
6862 {
6863 if (section->sh_type == SHT_GROUP)
6864 {
6865 const char * name = printable_section_name (filedata, section);
6866 const char * group_name;
6867 unsigned char * start;
6868 unsigned char * indices;
6869 unsigned int entry, j, size;
6870 Elf_Internal_Shdr * sec;
6871 Elf_Internal_Sym * sym;
6872
6873 /* Get the symbol table. */
6874 if (section->sh_link >= filedata->file_header.e_shnum
6875 || ((sec = filedata->section_headers + section->sh_link)->sh_type
6876 != SHT_SYMTAB))
6877 {
6878 error (_("Bad sh_link in group section `%s'\n"), name);
6879 continue;
6880 }
6881
6882 if (symtab_sec != sec)
6883 {
6884 symtab_sec = sec;
6885 if (symtab)
6886 free (symtab);
6887 symtab = GET_ELF_SYMBOLS (filedata, symtab_sec, & num_syms);
6888 }
6889
6890 if (symtab == NULL)
6891 {
6892 error (_("Corrupt header in group section `%s'\n"), name);
6893 continue;
6894 }
6895
6896 if (section->sh_info >= num_syms)
6897 {
6898 error (_("Bad sh_info in group section `%s'\n"), name);
6899 continue;
6900 }
6901
6902 sym = symtab + section->sh_info;
6903
6904 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6905 {
6906 if (sym->st_shndx == 0
6907 || sym->st_shndx >= filedata->file_header.e_shnum)
6908 {
6909 error (_("Bad sh_info in group section `%s'\n"), name);
6910 continue;
6911 }
6912
6913 group_name = SECTION_NAME (filedata->section_headers + sym->st_shndx);
6914 strtab_sec = NULL;
6915 if (strtab)
6916 free (strtab);
6917 strtab = NULL;
6918 strtab_size = 0;
6919 }
6920 else
6921 {
6922 /* Get the string table. */
6923 if (symtab_sec->sh_link >= filedata->file_header.e_shnum)
6924 {
6925 strtab_sec = NULL;
6926 if (strtab)
6927 free (strtab);
6928 strtab = NULL;
6929 strtab_size = 0;
6930 }
6931 else if (strtab_sec
6932 != (sec = filedata->section_headers + symtab_sec->sh_link))
6933 {
6934 strtab_sec = sec;
6935 if (strtab)
6936 free (strtab);
6937
6938 strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
6939 1, strtab_sec->sh_size,
6940 _("string table"));
6941 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6942 }
6943 group_name = sym->st_name < strtab_size
6944 ? strtab + sym->st_name : _("<corrupt>");
6945 }
6946
6947 /* PR 17531: file: loop. */
6948 if (section->sh_entsize > section->sh_size)
6949 {
6950 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6951 printable_section_name (filedata, section),
6952 (unsigned long) section->sh_entsize,
6953 (unsigned long) section->sh_size);
6954 continue;
6955 }
6956
6957 start = (unsigned char *) get_data (NULL, filedata, section->sh_offset,
6958 1, section->sh_size,
6959 _("section data"));
6960 if (start == NULL)
6961 continue;
6962
6963 indices = start;
6964 size = (section->sh_size / section->sh_entsize) - 1;
6965 entry = byte_get (indices, 4);
6966 indices += 4;
6967
6968 if (do_section_groups)
6969 {
6970 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6971 get_group_flags (entry), i, name, group_name, size);
6972
6973 printf (_(" [Index] Name\n"));
6974 }
6975
6976 group->group_index = i;
6977
6978 for (j = 0; j < size; j++)
6979 {
6980 struct group_list * g;
6981
6982 entry = byte_get (indices, 4);
6983 indices += 4;
6984
6985 if (entry >= filedata->file_header.e_shnum)
6986 {
6987 static unsigned num_group_errors = 0;
6988
6989 if (num_group_errors ++ < 10)
6990 {
6991 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6992 entry, i, filedata->file_header.e_shnum - 1);
6993 if (num_group_errors == 10)
6994 warn (_("Further error messages about overlarge group section indices suppressed\n"));
6995 }
6996 continue;
6997 }
6998
6999 if (section_headers_groups [entry] != NULL)
7000 {
7001 if (entry)
7002 {
7003 static unsigned num_errs = 0;
7004
7005 if (num_errs ++ < 10)
7006 {
7007 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
7008 entry, i,
7009 section_headers_groups [entry]->group_index);
7010 if (num_errs == 10)
7011 warn (_("Further error messages about already contained group sections suppressed\n"));
7012 }
7013 continue;
7014 }
7015 else
7016 {
7017 /* Intel C/C++ compiler may put section 0 in a
7018 section group. We just warn it the first time
7019 and ignore it afterwards. */
7020 static bfd_boolean warned = FALSE;
7021 if (!warned)
7022 {
7023 error (_("section 0 in group section [%5u]\n"),
7024 section_headers_groups [entry]->group_index);
7025 warned = TRUE;
7026 }
7027 }
7028 }
7029
7030 section_headers_groups [entry] = group;
7031
7032 if (do_section_groups)
7033 {
7034 sec = filedata->section_headers + entry;
7035 printf (" [%5u] %s\n", entry, printable_section_name (filedata, sec));
7036 }
7037
7038 g = (struct group_list *) xmalloc (sizeof (struct group_list));
7039 g->section_index = entry;
7040 g->next = group->root;
7041 group->root = g;
7042 }
7043
7044 if (start)
7045 free (start);
7046
7047 group++;
7048 }
7049 }
7050
7051 if (symtab)
7052 free (symtab);
7053 if (strtab)
7054 free (strtab);
7055 return TRUE;
7056 }
7057
7058 /* Data used to display dynamic fixups. */
7059
7060 struct ia64_vms_dynfixup
7061 {
7062 bfd_vma needed_ident; /* Library ident number. */
7063 bfd_vma needed; /* Index in the dstrtab of the library name. */
7064 bfd_vma fixup_needed; /* Index of the library. */
7065 bfd_vma fixup_rela_cnt; /* Number of fixups. */
7066 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
7067 };
7068
7069 /* Data used to display dynamic relocations. */
7070
7071 struct ia64_vms_dynimgrela
7072 {
7073 bfd_vma img_rela_cnt; /* Number of relocations. */
7074 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
7075 };
7076
7077 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7078 library). */
7079
7080 static bfd_boolean
dump_ia64_vms_dynamic_fixups(Filedata * filedata,struct ia64_vms_dynfixup * fixup,const char * strtab,unsigned int strtab_sz)7081 dump_ia64_vms_dynamic_fixups (Filedata * filedata,
7082 struct ia64_vms_dynfixup * fixup,
7083 const char * strtab,
7084 unsigned int strtab_sz)
7085 {
7086 Elf64_External_VMS_IMAGE_FIXUP * imfs;
7087 long i;
7088 const char * lib_name;
7089
7090 imfs = get_data (NULL, filedata, dynamic_addr + fixup->fixup_rela_off,
7091 1, fixup->fixup_rela_cnt * sizeof (*imfs),
7092 _("dynamic section image fixups"));
7093 if (!imfs)
7094 return FALSE;
7095
7096 if (fixup->needed < strtab_sz)
7097 lib_name = strtab + fixup->needed;
7098 else
7099 {
7100 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7101 (unsigned long) fixup->needed);
7102 lib_name = "???";
7103 }
7104 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7105 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
7106 printf
7107 (_("Seg Offset Type SymVec DataType\n"));
7108
7109 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
7110 {
7111 unsigned int type;
7112 const char *rtype;
7113
7114 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
7115 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
7116 type = BYTE_GET (imfs [i].type);
7117 rtype = elf_ia64_reloc_type (type);
7118 if (rtype == NULL)
7119 printf (" 0x%08x ", type);
7120 else
7121 printf (" %-32s ", rtype);
7122 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
7123 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
7124 }
7125
7126 free (imfs);
7127 return TRUE;
7128 }
7129
7130 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7131
7132 static bfd_boolean
dump_ia64_vms_dynamic_relocs(Filedata * filedata,struct ia64_vms_dynimgrela * imgrela)7133 dump_ia64_vms_dynamic_relocs (Filedata * filedata, struct ia64_vms_dynimgrela *imgrela)
7134 {
7135 Elf64_External_VMS_IMAGE_RELA *imrs;
7136 long i;
7137
7138 imrs = get_data (NULL, filedata, dynamic_addr + imgrela->img_rela_off,
7139 1, imgrela->img_rela_cnt * sizeof (*imrs),
7140 _("dynamic section image relocations"));
7141 if (!imrs)
7142 return FALSE;
7143
7144 printf (_("\nImage relocs\n"));
7145 printf
7146 (_("Seg Offset Type Addend Seg Sym Off\n"));
7147
7148 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
7149 {
7150 unsigned int type;
7151 const char *rtype;
7152
7153 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
7154 printf ("%08" BFD_VMA_FMT "x ",
7155 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
7156 type = BYTE_GET (imrs [i].type);
7157 rtype = elf_ia64_reloc_type (type);
7158 if (rtype == NULL)
7159 printf ("0x%08x ", type);
7160 else
7161 printf ("%-31s ", rtype);
7162 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
7163 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
7164 printf ("%08" BFD_VMA_FMT "x\n",
7165 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
7166 }
7167
7168 free (imrs);
7169 return TRUE;
7170 }
7171
7172 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7173
7174 static bfd_boolean
process_ia64_vms_dynamic_relocs(Filedata * filedata)7175 process_ia64_vms_dynamic_relocs (Filedata * filedata)
7176 {
7177 struct ia64_vms_dynfixup fixup;
7178 struct ia64_vms_dynimgrela imgrela;
7179 Elf_Internal_Dyn *entry;
7180 bfd_vma strtab_off = 0;
7181 bfd_vma strtab_sz = 0;
7182 char *strtab = NULL;
7183 bfd_boolean res = TRUE;
7184
7185 memset (&fixup, 0, sizeof (fixup));
7186 memset (&imgrela, 0, sizeof (imgrela));
7187
7188 /* Note: the order of the entries is specified by the OpenVMS specs. */
7189 for (entry = dynamic_section;
7190 entry < dynamic_section + dynamic_nent;
7191 entry++)
7192 {
7193 switch (entry->d_tag)
7194 {
7195 case DT_IA_64_VMS_STRTAB_OFFSET:
7196 strtab_off = entry->d_un.d_val;
7197 break;
7198 case DT_STRSZ:
7199 strtab_sz = entry->d_un.d_val;
7200 if (strtab == NULL)
7201 strtab = get_data (NULL, filedata, dynamic_addr + strtab_off,
7202 1, strtab_sz, _("dynamic string section"));
7203 break;
7204
7205 case DT_IA_64_VMS_NEEDED_IDENT:
7206 fixup.needed_ident = entry->d_un.d_val;
7207 break;
7208 case DT_NEEDED:
7209 fixup.needed = entry->d_un.d_val;
7210 break;
7211 case DT_IA_64_VMS_FIXUP_NEEDED:
7212 fixup.fixup_needed = entry->d_un.d_val;
7213 break;
7214 case DT_IA_64_VMS_FIXUP_RELA_CNT:
7215 fixup.fixup_rela_cnt = entry->d_un.d_val;
7216 break;
7217 case DT_IA_64_VMS_FIXUP_RELA_OFF:
7218 fixup.fixup_rela_off = entry->d_un.d_val;
7219 if (! dump_ia64_vms_dynamic_fixups (filedata, &fixup, strtab, strtab_sz))
7220 res = FALSE;
7221 break;
7222 case DT_IA_64_VMS_IMG_RELA_CNT:
7223 imgrela.img_rela_cnt = entry->d_un.d_val;
7224 break;
7225 case DT_IA_64_VMS_IMG_RELA_OFF:
7226 imgrela.img_rela_off = entry->d_un.d_val;
7227 if (! dump_ia64_vms_dynamic_relocs (filedata, &imgrela))
7228 res = FALSE;
7229 break;
7230
7231 default:
7232 break;
7233 }
7234 }
7235
7236 if (strtab != NULL)
7237 free (strtab);
7238
7239 return res;
7240 }
7241
7242 static struct
7243 {
7244 const char * name;
7245 int reloc;
7246 int size;
7247 int rela;
7248 }
7249 dynamic_relocations [] =
7250 {
7251 { "REL", DT_REL, DT_RELSZ, FALSE },
7252 { "RELA", DT_RELA, DT_RELASZ, TRUE },
7253 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
7254 };
7255
7256 /* Process the reloc section. */
7257
7258 static bfd_boolean
process_relocs(Filedata * filedata)7259 process_relocs (Filedata * filedata)
7260 {
7261 unsigned long rel_size;
7262 unsigned long rel_offset;
7263
7264 if (!do_reloc)
7265 return TRUE;
7266
7267 if (do_using_dynamic)
7268 {
7269 int is_rela;
7270 const char * name;
7271 bfd_boolean has_dynamic_reloc;
7272 unsigned int i;
7273
7274 has_dynamic_reloc = FALSE;
7275
7276 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7277 {
7278 is_rela = dynamic_relocations [i].rela;
7279 name = dynamic_relocations [i].name;
7280 rel_size = dynamic_info [dynamic_relocations [i].size];
7281 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
7282
7283 if (rel_size)
7284 has_dynamic_reloc = TRUE;
7285
7286 if (is_rela == UNKNOWN)
7287 {
7288 if (dynamic_relocations [i].reloc == DT_JMPREL)
7289 switch (dynamic_info[DT_PLTREL])
7290 {
7291 case DT_REL:
7292 is_rela = FALSE;
7293 break;
7294 case DT_RELA:
7295 is_rela = TRUE;
7296 break;
7297 }
7298 }
7299
7300 if (rel_size)
7301 {
7302 printf
7303 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7304 name, rel_offset, rel_size);
7305
7306 dump_relocations (filedata,
7307 offset_from_vma (filedata, rel_offset, rel_size),
7308 rel_size,
7309 dynamic_symbols, num_dynamic_syms,
7310 dynamic_strings, dynamic_strings_length,
7311 is_rela, TRUE /* is_dynamic */);
7312 }
7313 }
7314
7315 if (is_ia64_vms (filedata))
7316 if (process_ia64_vms_dynamic_relocs (filedata))
7317 has_dynamic_reloc = TRUE;
7318
7319 if (! has_dynamic_reloc)
7320 printf (_("\nThere are no dynamic relocations in this file.\n"));
7321 }
7322 else
7323 {
7324 Elf_Internal_Shdr * section;
7325 unsigned long i;
7326 bfd_boolean found = FALSE;
7327
7328 for (i = 0, section = filedata->section_headers;
7329 i < filedata->file_header.e_shnum;
7330 i++, section++)
7331 {
7332 if ( section->sh_type != SHT_RELA
7333 && section->sh_type != SHT_REL)
7334 continue;
7335
7336 rel_offset = section->sh_offset;
7337 rel_size = section->sh_size;
7338
7339 if (rel_size)
7340 {
7341 Elf_Internal_Shdr * strsec;
7342 int is_rela;
7343 unsigned long num_rela;
7344
7345 printf (_("\nRelocation section "));
7346
7347 if (filedata->string_table == NULL)
7348 printf ("%d", section->sh_name);
7349 else
7350 printf ("'%s'", printable_section_name (filedata, section));
7351
7352 num_rela = rel_size / section->sh_entsize;
7353 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7354 " at offset 0x%lx contains %lu entries:\n",
7355 num_rela),
7356 rel_offset, num_rela);
7357
7358 is_rela = section->sh_type == SHT_RELA;
7359
7360 if (section->sh_link != 0
7361 && section->sh_link < filedata->file_header.e_shnum)
7362 {
7363 Elf_Internal_Shdr * symsec;
7364 Elf_Internal_Sym * symtab;
7365 unsigned long nsyms;
7366 unsigned long strtablen = 0;
7367 char * strtab = NULL;
7368
7369 symsec = filedata->section_headers + section->sh_link;
7370 if (symsec->sh_type != SHT_SYMTAB
7371 && symsec->sh_type != SHT_DYNSYM)
7372 continue;
7373
7374 symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
7375
7376 if (symtab == NULL)
7377 continue;
7378
7379 if (symsec->sh_link != 0
7380 && symsec->sh_link < filedata->file_header.e_shnum)
7381 {
7382 strsec = filedata->section_headers + symsec->sh_link;
7383
7384 strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7385 1, strsec->sh_size,
7386 _("string table"));
7387 strtablen = strtab == NULL ? 0 : strsec->sh_size;
7388 }
7389
7390 dump_relocations (filedata, rel_offset, rel_size,
7391 symtab, nsyms, strtab, strtablen,
7392 is_rela,
7393 symsec->sh_type == SHT_DYNSYM);
7394 if (strtab)
7395 free (strtab);
7396 free (symtab);
7397 }
7398 else
7399 dump_relocations (filedata, rel_offset, rel_size,
7400 NULL, 0, NULL, 0, is_rela,
7401 FALSE /* is_dynamic */);
7402
7403 found = TRUE;
7404 }
7405 }
7406
7407 if (! found)
7408 {
7409 /* Users sometimes forget the -D option, so try to be helpful. */
7410 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7411 {
7412 if (dynamic_info [dynamic_relocations [i].size])
7413 {
7414 printf (_("\nThere are no static relocations in this file."));
7415 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7416
7417 break;
7418 }
7419 }
7420 if (i == ARRAY_SIZE (dynamic_relocations))
7421 printf (_("\nThere are no relocations in this file.\n"));
7422 }
7423 }
7424
7425 return TRUE;
7426 }
7427
7428 /* An absolute address consists of a section and an offset. If the
7429 section is NULL, the offset itself is the address, otherwise, the
7430 address equals to LOAD_ADDRESS(section) + offset. */
7431
7432 struct absaddr
7433 {
7434 unsigned short section;
7435 bfd_vma offset;
7436 };
7437
7438 /* Find the nearest symbol at or below ADDR. Returns the symbol
7439 name, if found, and the offset from the symbol to ADDR. */
7440
7441 static void
find_symbol_for_address(Filedata * filedata,Elf_Internal_Sym * symtab,unsigned long nsyms,const char * strtab,unsigned long strtab_size,struct absaddr addr,const char ** symname,bfd_vma * offset)7442 find_symbol_for_address (Filedata * filedata,
7443 Elf_Internal_Sym * symtab,
7444 unsigned long nsyms,
7445 const char * strtab,
7446 unsigned long strtab_size,
7447 struct absaddr addr,
7448 const char ** symname,
7449 bfd_vma * offset)
7450 {
7451 bfd_vma dist = 0x100000;
7452 Elf_Internal_Sym * sym;
7453 Elf_Internal_Sym * beg;
7454 Elf_Internal_Sym * end;
7455 Elf_Internal_Sym * best = NULL;
7456
7457 REMOVE_ARCH_BITS (addr.offset);
7458 beg = symtab;
7459 end = symtab + nsyms;
7460
7461 while (beg < end)
7462 {
7463 bfd_vma value;
7464
7465 sym = beg + (end - beg) / 2;
7466
7467 value = sym->st_value;
7468 REMOVE_ARCH_BITS (value);
7469
7470 if (sym->st_name != 0
7471 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
7472 && addr.offset >= value
7473 && addr.offset - value < dist)
7474 {
7475 best = sym;
7476 dist = addr.offset - value;
7477 if (!dist)
7478 break;
7479 }
7480
7481 if (addr.offset < value)
7482 end = sym;
7483 else
7484 beg = sym + 1;
7485 }
7486
7487 if (best)
7488 {
7489 *symname = (best->st_name >= strtab_size
7490 ? _("<corrupt>") : strtab + best->st_name);
7491 *offset = dist;
7492 return;
7493 }
7494
7495 *symname = NULL;
7496 *offset = addr.offset;
7497 }
7498
7499 static /* signed */ int
symcmp(const void * p,const void * q)7500 symcmp (const void *p, const void *q)
7501 {
7502 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7503 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7504
7505 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7506 }
7507
7508 /* Process the unwind section. */
7509
7510 #include "unwind-ia64.h"
7511
7512 struct ia64_unw_table_entry
7513 {
7514 struct absaddr start;
7515 struct absaddr end;
7516 struct absaddr info;
7517 };
7518
7519 struct ia64_unw_aux_info
7520 {
7521 struct ia64_unw_table_entry * table; /* Unwind table. */
7522 unsigned long table_len; /* Length of unwind table. */
7523 unsigned char * info; /* Unwind info. */
7524 unsigned long info_size; /* Size of unwind info. */
7525 bfd_vma info_addr; /* Starting address of unwind info. */
7526 bfd_vma seg_base; /* Starting address of segment. */
7527 Elf_Internal_Sym * symtab; /* The symbol table. */
7528 unsigned long nsyms; /* Number of symbols. */
7529 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7530 unsigned long nfuns; /* Number of entries in funtab. */
7531 char * strtab; /* The string table. */
7532 unsigned long strtab_size; /* Size of string table. */
7533 };
7534
7535 static bfd_boolean
dump_ia64_unwind(Filedata * filedata,struct ia64_unw_aux_info * aux)7536 dump_ia64_unwind (Filedata * filedata, struct ia64_unw_aux_info * aux)
7537 {
7538 struct ia64_unw_table_entry * tp;
7539 unsigned long j, nfuns;
7540 int in_body;
7541 bfd_boolean res = TRUE;
7542
7543 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7544 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7545 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7546 aux->funtab[nfuns++] = aux->symtab[j];
7547 aux->nfuns = nfuns;
7548 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7549
7550 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7551 {
7552 bfd_vma stamp;
7553 bfd_vma offset;
7554 const unsigned char * dp;
7555 const unsigned char * head;
7556 const unsigned char * end;
7557 const char * procname;
7558
7559 find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7560 aux->strtab_size, tp->start, &procname, &offset);
7561
7562 fputs ("\n<", stdout);
7563
7564 if (procname)
7565 {
7566 fputs (procname, stdout);
7567
7568 if (offset)
7569 printf ("+%lx", (unsigned long) offset);
7570 }
7571
7572 fputs (">: [", stdout);
7573 print_vma (tp->start.offset, PREFIX_HEX);
7574 fputc ('-', stdout);
7575 print_vma (tp->end.offset, PREFIX_HEX);
7576 printf ("], info at +0x%lx\n",
7577 (unsigned long) (tp->info.offset - aux->seg_base));
7578
7579 /* PR 17531: file: 86232b32. */
7580 if (aux->info == NULL)
7581 continue;
7582
7583 offset = tp->info.offset;
7584 if (tp->info.section)
7585 {
7586 if (tp->info.section >= filedata->file_header.e_shnum)
7587 {
7588 warn (_("Invalid section %u in table entry %ld\n"),
7589 tp->info.section, (long) (tp - aux->table));
7590 res = FALSE;
7591 continue;
7592 }
7593 offset += filedata->section_headers[tp->info.section].sh_addr;
7594 }
7595 offset -= aux->info_addr;
7596 /* PR 17531: file: 0997b4d1. */
7597 if (offset >= aux->info_size
7598 || aux->info_size - offset < 8)
7599 {
7600 warn (_("Invalid offset %lx in table entry %ld\n"),
7601 (long) tp->info.offset, (long) (tp - aux->table));
7602 res = FALSE;
7603 continue;
7604 }
7605
7606 head = aux->info + offset;
7607 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
7608
7609 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7610 (unsigned) UNW_VER (stamp),
7611 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7612 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7613 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
7614 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
7615
7616 if (UNW_VER (stamp) != 1)
7617 {
7618 printf (_("\tUnknown version.\n"));
7619 continue;
7620 }
7621
7622 in_body = 0;
7623 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7624 /* PR 17531: file: 16ceda89. */
7625 if (end > aux->info + aux->info_size)
7626 end = aux->info + aux->info_size;
7627 for (dp = head + 8; dp < end;)
7628 dp = unw_decode (dp, in_body, & in_body, end);
7629 }
7630
7631 free (aux->funtab);
7632
7633 return res;
7634 }
7635
7636 static bfd_boolean
slurp_ia64_unwind_table(Filedata * filedata,struct ia64_unw_aux_info * aux,Elf_Internal_Shdr * sec)7637 slurp_ia64_unwind_table (Filedata * filedata,
7638 struct ia64_unw_aux_info * aux,
7639 Elf_Internal_Shdr * sec)
7640 {
7641 unsigned long size, nrelas, i;
7642 Elf_Internal_Phdr * seg;
7643 struct ia64_unw_table_entry * tep;
7644 Elf_Internal_Shdr * relsec;
7645 Elf_Internal_Rela * rela;
7646 Elf_Internal_Rela * rp;
7647 unsigned char * table;
7648 unsigned char * tp;
7649 Elf_Internal_Sym * sym;
7650 const char * relname;
7651
7652 aux->table_len = 0;
7653
7654 /* First, find the starting address of the segment that includes
7655 this section: */
7656
7657 if (filedata->file_header.e_phnum)
7658 {
7659 if (! get_program_headers (filedata))
7660 return FALSE;
7661
7662 for (seg = filedata->program_headers;
7663 seg < filedata->program_headers + filedata->file_header.e_phnum;
7664 ++seg)
7665 {
7666 if (seg->p_type != PT_LOAD)
7667 continue;
7668
7669 if (sec->sh_addr >= seg->p_vaddr
7670 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7671 {
7672 aux->seg_base = seg->p_vaddr;
7673 break;
7674 }
7675 }
7676 }
7677
7678 /* Second, build the unwind table from the contents of the unwind section: */
7679 size = sec->sh_size;
7680 table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7681 _("unwind table"));
7682 if (!table)
7683 return FALSE;
7684
7685 aux->table_len = size / (3 * eh_addr_size);
7686 aux->table = (struct ia64_unw_table_entry *)
7687 xcmalloc (aux->table_len, sizeof (aux->table[0]));
7688 tep = aux->table;
7689
7690 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7691 {
7692 tep->start.section = SHN_UNDEF;
7693 tep->end.section = SHN_UNDEF;
7694 tep->info.section = SHN_UNDEF;
7695 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7696 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7697 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7698 tep->start.offset += aux->seg_base;
7699 tep->end.offset += aux->seg_base;
7700 tep->info.offset += aux->seg_base;
7701 }
7702 free (table);
7703
7704 /* Third, apply any relocations to the unwind table: */
7705 for (relsec = filedata->section_headers;
7706 relsec < filedata->section_headers + filedata->file_header.e_shnum;
7707 ++relsec)
7708 {
7709 if (relsec->sh_type != SHT_RELA
7710 || relsec->sh_info >= filedata->file_header.e_shnum
7711 || filedata->section_headers + relsec->sh_info != sec)
7712 continue;
7713
7714 if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
7715 & rela, & nrelas))
7716 {
7717 free (aux->table);
7718 aux->table = NULL;
7719 aux->table_len = 0;
7720 return FALSE;
7721 }
7722
7723 for (rp = rela; rp < rela + nrelas; ++rp)
7724 {
7725 unsigned int sym_ndx;
7726 unsigned int r_type = get_reloc_type (filedata, rp->r_info);
7727 relname = elf_ia64_reloc_type (r_type);
7728
7729 /* PR 17531: file: 9fa67536. */
7730 if (relname == NULL)
7731 {
7732 warn (_("Skipping unknown relocation type: %u\n"), r_type);
7733 continue;
7734 }
7735
7736 if (! const_strneq (relname, "R_IA64_SEGREL"))
7737 {
7738 warn (_("Skipping unexpected relocation type: %s\n"), relname);
7739 continue;
7740 }
7741
7742 i = rp->r_offset / (3 * eh_addr_size);
7743
7744 /* PR 17531: file: 5bc8d9bf. */
7745 if (i >= aux->table_len)
7746 {
7747 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7748 continue;
7749 }
7750
7751 sym_ndx = get_reloc_symindex (rp->r_info);
7752 if (sym_ndx >= aux->nsyms)
7753 {
7754 warn (_("Skipping reloc with invalid symbol index: %u\n"),
7755 sym_ndx);
7756 continue;
7757 }
7758 sym = aux->symtab + sym_ndx;
7759
7760 switch (rp->r_offset / eh_addr_size % 3)
7761 {
7762 case 0:
7763 aux->table[i].start.section = sym->st_shndx;
7764 aux->table[i].start.offset = rp->r_addend + sym->st_value;
7765 break;
7766 case 1:
7767 aux->table[i].end.section = sym->st_shndx;
7768 aux->table[i].end.offset = rp->r_addend + sym->st_value;
7769 break;
7770 case 2:
7771 aux->table[i].info.section = sym->st_shndx;
7772 aux->table[i].info.offset = rp->r_addend + sym->st_value;
7773 break;
7774 default:
7775 break;
7776 }
7777 }
7778
7779 free (rela);
7780 }
7781
7782 return TRUE;
7783 }
7784
7785 static bfd_boolean
ia64_process_unwind(Filedata * filedata)7786 ia64_process_unwind (Filedata * filedata)
7787 {
7788 Elf_Internal_Shdr * sec;
7789 Elf_Internal_Shdr * unwsec = NULL;
7790 Elf_Internal_Shdr * strsec;
7791 unsigned long i, unwcount = 0, unwstart = 0;
7792 struct ia64_unw_aux_info aux;
7793 bfd_boolean res = TRUE;
7794
7795 memset (& aux, 0, sizeof (aux));
7796
7797 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
7798 {
7799 if (sec->sh_type == SHT_SYMTAB
7800 && sec->sh_link < filedata->file_header.e_shnum)
7801 {
7802 aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
7803
7804 strsec = filedata->section_headers + sec->sh_link;
7805 if (aux.strtab != NULL)
7806 {
7807 error (_("Multiple auxillary string tables encountered\n"));
7808 free (aux.strtab);
7809 res = FALSE;
7810 }
7811 aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7812 1, strsec->sh_size,
7813 _("string table"));
7814 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7815 }
7816 else if (sec->sh_type == SHT_IA_64_UNWIND)
7817 unwcount++;
7818 }
7819
7820 if (!unwcount)
7821 printf (_("\nThere are no unwind sections in this file.\n"));
7822
7823 while (unwcount-- > 0)
7824 {
7825 char * suffix;
7826 size_t len, len2;
7827
7828 for (i = unwstart, sec = filedata->section_headers + unwstart, unwsec = NULL;
7829 i < filedata->file_header.e_shnum; ++i, ++sec)
7830 if (sec->sh_type == SHT_IA_64_UNWIND)
7831 {
7832 unwsec = sec;
7833 break;
7834 }
7835 /* We have already counted the number of SHT_IA64_UNWIND
7836 sections so the loop above should never fail. */
7837 assert (unwsec != NULL);
7838
7839 unwstart = i + 1;
7840 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7841
7842 if ((unwsec->sh_flags & SHF_GROUP) != 0)
7843 {
7844 /* We need to find which section group it is in. */
7845 struct group_list * g;
7846
7847 if (section_headers_groups == NULL
7848 || section_headers_groups [i] == NULL)
7849 i = filedata->file_header.e_shnum;
7850 else
7851 {
7852 g = section_headers_groups [i]->root;
7853
7854 for (; g != NULL; g = g->next)
7855 {
7856 sec = filedata->section_headers + g->section_index;
7857
7858 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7859 break;
7860 }
7861
7862 if (g == NULL)
7863 i = filedata->file_header.e_shnum;
7864 }
7865 }
7866 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7867 {
7868 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7869 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7870 suffix = SECTION_NAME (unwsec) + len;
7871 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7872 ++i, ++sec)
7873 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7874 && streq (SECTION_NAME (sec) + len2, suffix))
7875 break;
7876 }
7877 else
7878 {
7879 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7880 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7881 len = sizeof (ELF_STRING_ia64_unwind) - 1;
7882 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7883 suffix = "";
7884 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7885 suffix = SECTION_NAME (unwsec) + len;
7886 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7887 ++i, ++sec)
7888 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7889 && streq (SECTION_NAME (sec) + len2, suffix))
7890 break;
7891 }
7892
7893 if (i == filedata->file_header.e_shnum)
7894 {
7895 printf (_("\nCould not find unwind info section for "));
7896
7897 if (filedata->string_table == NULL)
7898 printf ("%d", unwsec->sh_name);
7899 else
7900 printf ("'%s'", printable_section_name (filedata, unwsec));
7901 }
7902 else
7903 {
7904 aux.info_addr = sec->sh_addr;
7905 aux.info = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1,
7906 sec->sh_size,
7907 _("unwind info"));
7908 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7909
7910 printf (_("\nUnwind section "));
7911
7912 if (filedata->string_table == NULL)
7913 printf ("%d", unwsec->sh_name);
7914 else
7915 printf ("'%s'", printable_section_name (filedata, unwsec));
7916
7917 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7918 (unsigned long) unwsec->sh_offset,
7919 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7920
7921 if (slurp_ia64_unwind_table (filedata, & aux, unwsec)
7922 && aux.table_len > 0)
7923 dump_ia64_unwind (filedata, & aux);
7924
7925 if (aux.table)
7926 free ((char *) aux.table);
7927 if (aux.info)
7928 free ((char *) aux.info);
7929 aux.table = NULL;
7930 aux.info = NULL;
7931 }
7932 }
7933
7934 if (aux.symtab)
7935 free (aux.symtab);
7936 if (aux.strtab)
7937 free ((char *) aux.strtab);
7938
7939 return res;
7940 }
7941
7942 struct hppa_unw_table_entry
7943 {
7944 struct absaddr start;
7945 struct absaddr end;
7946 unsigned int Cannot_unwind:1; /* 0 */
7947 unsigned int Millicode:1; /* 1 */
7948 unsigned int Millicode_save_sr0:1; /* 2 */
7949 unsigned int Region_description:2; /* 3..4 */
7950 unsigned int reserved1:1; /* 5 */
7951 unsigned int Entry_SR:1; /* 6 */
7952 unsigned int Entry_FR:4; /* Number saved 7..10 */
7953 unsigned int Entry_GR:5; /* Number saved 11..15 */
7954 unsigned int Args_stored:1; /* 16 */
7955 unsigned int Variable_Frame:1; /* 17 */
7956 unsigned int Separate_Package_Body:1; /* 18 */
7957 unsigned int Frame_Extension_Millicode:1; /* 19 */
7958 unsigned int Stack_Overflow_Check:1; /* 20 */
7959 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
7960 unsigned int Ada_Region:1; /* 22 */
7961 unsigned int cxx_info:1; /* 23 */
7962 unsigned int cxx_try_catch:1; /* 24 */
7963 unsigned int sched_entry_seq:1; /* 25 */
7964 unsigned int reserved2:1; /* 26 */
7965 unsigned int Save_SP:1; /* 27 */
7966 unsigned int Save_RP:1; /* 28 */
7967 unsigned int Save_MRP_in_frame:1; /* 29 */
7968 unsigned int extn_ptr_defined:1; /* 30 */
7969 unsigned int Cleanup_defined:1; /* 31 */
7970
7971 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
7972 unsigned int HP_UX_interrupt_marker:1; /* 1 */
7973 unsigned int Large_frame:1; /* 2 */
7974 unsigned int Pseudo_SP_Set:1; /* 3 */
7975 unsigned int reserved4:1; /* 4 */
7976 unsigned int Total_frame_size:27; /* 5..31 */
7977 };
7978
7979 struct hppa_unw_aux_info
7980 {
7981 struct hppa_unw_table_entry * table; /* Unwind table. */
7982 unsigned long table_len; /* Length of unwind table. */
7983 bfd_vma seg_base; /* Starting address of segment. */
7984 Elf_Internal_Sym * symtab; /* The symbol table. */
7985 unsigned long nsyms; /* Number of symbols. */
7986 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7987 unsigned long nfuns; /* Number of entries in funtab. */
7988 char * strtab; /* The string table. */
7989 unsigned long strtab_size; /* Size of string table. */
7990 };
7991
7992 static bfd_boolean
dump_hppa_unwind(Filedata * filedata,struct hppa_unw_aux_info * aux)7993 dump_hppa_unwind (Filedata * filedata, struct hppa_unw_aux_info * aux)
7994 {
7995 struct hppa_unw_table_entry * tp;
7996 unsigned long j, nfuns;
7997 bfd_boolean res = TRUE;
7998
7999 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8000 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8001 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8002 aux->funtab[nfuns++] = aux->symtab[j];
8003 aux->nfuns = nfuns;
8004 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8005
8006 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
8007 {
8008 bfd_vma offset;
8009 const char * procname;
8010
8011 find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
8012 aux->strtab_size, tp->start, &procname,
8013 &offset);
8014
8015 fputs ("\n<", stdout);
8016
8017 if (procname)
8018 {
8019 fputs (procname, stdout);
8020
8021 if (offset)
8022 printf ("+%lx", (unsigned long) offset);
8023 }
8024
8025 fputs (">: [", stdout);
8026 print_vma (tp->start.offset, PREFIX_HEX);
8027 fputc ('-', stdout);
8028 print_vma (tp->end.offset, PREFIX_HEX);
8029 printf ("]\n\t");
8030
8031 #define PF(_m) if (tp->_m) printf (#_m " ");
8032 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8033 PF(Cannot_unwind);
8034 PF(Millicode);
8035 PF(Millicode_save_sr0);
8036 /* PV(Region_description); */
8037 PF(Entry_SR);
8038 PV(Entry_FR);
8039 PV(Entry_GR);
8040 PF(Args_stored);
8041 PF(Variable_Frame);
8042 PF(Separate_Package_Body);
8043 PF(Frame_Extension_Millicode);
8044 PF(Stack_Overflow_Check);
8045 PF(Two_Instruction_SP_Increment);
8046 PF(Ada_Region);
8047 PF(cxx_info);
8048 PF(cxx_try_catch);
8049 PF(sched_entry_seq);
8050 PF(Save_SP);
8051 PF(Save_RP);
8052 PF(Save_MRP_in_frame);
8053 PF(extn_ptr_defined);
8054 PF(Cleanup_defined);
8055 PF(MPE_XL_interrupt_marker);
8056 PF(HP_UX_interrupt_marker);
8057 PF(Large_frame);
8058 PF(Pseudo_SP_Set);
8059 PV(Total_frame_size);
8060 #undef PF
8061 #undef PV
8062 }
8063
8064 printf ("\n");
8065
8066 free (aux->funtab);
8067
8068 return res;
8069 }
8070
8071 static bfd_boolean
slurp_hppa_unwind_table(Filedata * filedata,struct hppa_unw_aux_info * aux,Elf_Internal_Shdr * sec)8072 slurp_hppa_unwind_table (Filedata * filedata,
8073 struct hppa_unw_aux_info * aux,
8074 Elf_Internal_Shdr * sec)
8075 {
8076 unsigned long size, unw_ent_size, nentries, nrelas, i;
8077 Elf_Internal_Phdr * seg;
8078 struct hppa_unw_table_entry * tep;
8079 Elf_Internal_Shdr * relsec;
8080 Elf_Internal_Rela * rela;
8081 Elf_Internal_Rela * rp;
8082 unsigned char * table;
8083 unsigned char * tp;
8084 Elf_Internal_Sym * sym;
8085 const char * relname;
8086
8087 /* First, find the starting address of the segment that includes
8088 this section. */
8089 if (filedata->file_header.e_phnum)
8090 {
8091 if (! get_program_headers (filedata))
8092 return FALSE;
8093
8094 for (seg = filedata->program_headers;
8095 seg < filedata->program_headers + filedata->file_header.e_phnum;
8096 ++seg)
8097 {
8098 if (seg->p_type != PT_LOAD)
8099 continue;
8100
8101 if (sec->sh_addr >= seg->p_vaddr
8102 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
8103 {
8104 aux->seg_base = seg->p_vaddr;
8105 break;
8106 }
8107 }
8108 }
8109
8110 /* Second, build the unwind table from the contents of the unwind
8111 section. */
8112 size = sec->sh_size;
8113 table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
8114 _("unwind table"));
8115 if (!table)
8116 return FALSE;
8117
8118 unw_ent_size = 16;
8119 nentries = size / unw_ent_size;
8120 size = unw_ent_size * nentries;
8121
8122 tep = aux->table = (struct hppa_unw_table_entry *)
8123 xcmalloc (nentries, sizeof (aux->table[0]));
8124
8125 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
8126 {
8127 unsigned int tmp1, tmp2;
8128
8129 tep->start.section = SHN_UNDEF;
8130 tep->end.section = SHN_UNDEF;
8131
8132 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
8133 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
8134 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
8135 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
8136
8137 tep->start.offset += aux->seg_base;
8138 tep->end.offset += aux->seg_base;
8139
8140 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
8141 tep->Millicode = (tmp1 >> 30) & 0x1;
8142 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
8143 tep->Region_description = (tmp1 >> 27) & 0x3;
8144 tep->reserved1 = (tmp1 >> 26) & 0x1;
8145 tep->Entry_SR = (tmp1 >> 25) & 0x1;
8146 tep->Entry_FR = (tmp1 >> 21) & 0xf;
8147 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
8148 tep->Args_stored = (tmp1 >> 15) & 0x1;
8149 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
8150 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
8151 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
8152 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
8153 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
8154 tep->Ada_Region = (tmp1 >> 9) & 0x1;
8155 tep->cxx_info = (tmp1 >> 8) & 0x1;
8156 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
8157 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
8158 tep->reserved2 = (tmp1 >> 5) & 0x1;
8159 tep->Save_SP = (tmp1 >> 4) & 0x1;
8160 tep->Save_RP = (tmp1 >> 3) & 0x1;
8161 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
8162 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
8163 tep->Cleanup_defined = tmp1 & 0x1;
8164
8165 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
8166 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
8167 tep->Large_frame = (tmp2 >> 29) & 0x1;
8168 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
8169 tep->reserved4 = (tmp2 >> 27) & 0x1;
8170 tep->Total_frame_size = tmp2 & 0x7ffffff;
8171 }
8172 free (table);
8173
8174 /* Third, apply any relocations to the unwind table. */
8175 for (relsec = filedata->section_headers;
8176 relsec < filedata->section_headers + filedata->file_header.e_shnum;
8177 ++relsec)
8178 {
8179 if (relsec->sh_type != SHT_RELA
8180 || relsec->sh_info >= filedata->file_header.e_shnum
8181 || filedata->section_headers + relsec->sh_info != sec)
8182 continue;
8183
8184 if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
8185 & rela, & nrelas))
8186 return FALSE;
8187
8188 for (rp = rela; rp < rela + nrelas; ++rp)
8189 {
8190 unsigned int sym_ndx;
8191 unsigned int r_type = get_reloc_type (filedata, rp->r_info);
8192 relname = elf_hppa_reloc_type (r_type);
8193
8194 if (relname == NULL)
8195 {
8196 warn (_("Skipping unknown relocation type: %u\n"), r_type);
8197 continue;
8198 }
8199
8200 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8201 if (! const_strneq (relname, "R_PARISC_SEGREL"))
8202 {
8203 warn (_("Skipping unexpected relocation type: %s\n"), relname);
8204 continue;
8205 }
8206
8207 i = rp->r_offset / unw_ent_size;
8208 if (i >= aux->table_len)
8209 {
8210 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
8211 continue;
8212 }
8213
8214 sym_ndx = get_reloc_symindex (rp->r_info);
8215 if (sym_ndx >= aux->nsyms)
8216 {
8217 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8218 sym_ndx);
8219 continue;
8220 }
8221 sym = aux->symtab + sym_ndx;
8222
8223 switch ((rp->r_offset % unw_ent_size) / 4)
8224 {
8225 case 0:
8226 aux->table[i].start.section = sym->st_shndx;
8227 aux->table[i].start.offset = sym->st_value + rp->r_addend;
8228 break;
8229 case 1:
8230 aux->table[i].end.section = sym->st_shndx;
8231 aux->table[i].end.offset = sym->st_value + rp->r_addend;
8232 break;
8233 default:
8234 break;
8235 }
8236 }
8237
8238 free (rela);
8239 }
8240
8241 aux->table_len = nentries;
8242
8243 return TRUE;
8244 }
8245
8246 static bfd_boolean
hppa_process_unwind(Filedata * filedata)8247 hppa_process_unwind (Filedata * filedata)
8248 {
8249 struct hppa_unw_aux_info aux;
8250 Elf_Internal_Shdr * unwsec = NULL;
8251 Elf_Internal_Shdr * strsec;
8252 Elf_Internal_Shdr * sec;
8253 unsigned long i;
8254 bfd_boolean res = TRUE;
8255
8256 if (filedata->string_table == NULL)
8257 return FALSE;
8258
8259 memset (& aux, 0, sizeof (aux));
8260
8261 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8262 {
8263 if (sec->sh_type == SHT_SYMTAB
8264 && sec->sh_link < filedata->file_header.e_shnum)
8265 {
8266 aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
8267
8268 strsec = filedata->section_headers + sec->sh_link;
8269 if (aux.strtab != NULL)
8270 {
8271 error (_("Multiple auxillary string tables encountered\n"));
8272 free (aux.strtab);
8273 res = FALSE;
8274 }
8275 aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
8276 1, strsec->sh_size,
8277 _("string table"));
8278 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8279 }
8280 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8281 unwsec = sec;
8282 }
8283
8284 if (!unwsec)
8285 printf (_("\nThere are no unwind sections in this file.\n"));
8286
8287 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8288 {
8289 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8290 {
8291 unsigned long num_unwind = sec->sh_size / 16;
8292
8293 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8294 "contains %lu entry:\n",
8295 "\nUnwind section '%s' at offset 0x%lx "
8296 "contains %lu entries:\n",
8297 num_unwind),
8298 printable_section_name (filedata, sec),
8299 (unsigned long) sec->sh_offset,
8300 num_unwind);
8301
8302 if (! slurp_hppa_unwind_table (filedata, &aux, sec))
8303 res = FALSE;
8304
8305 if (res && aux.table_len > 0)
8306 {
8307 if (! dump_hppa_unwind (filedata, &aux))
8308 res = FALSE;
8309 }
8310
8311 if (aux.table)
8312 free ((char *) aux.table);
8313 aux.table = NULL;
8314 }
8315 }
8316
8317 if (aux.symtab)
8318 free (aux.symtab);
8319 if (aux.strtab)
8320 free ((char *) aux.strtab);
8321
8322 return res;
8323 }
8324
8325 struct arm_section
8326 {
8327 unsigned char * data; /* The unwind data. */
8328 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
8329 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
8330 unsigned long nrelas; /* The number of relocations. */
8331 unsigned int rel_type; /* REL or RELA ? */
8332 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
8333 };
8334
8335 struct arm_unw_aux_info
8336 {
8337 Filedata * filedata; /* The file containing the unwind sections. */
8338 Elf_Internal_Sym * symtab; /* The file's symbol table. */
8339 unsigned long nsyms; /* Number of symbols. */
8340 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
8341 unsigned long nfuns; /* Number of these symbols. */
8342 char * strtab; /* The file's string table. */
8343 unsigned long strtab_size; /* Size of string table. */
8344 };
8345
8346 static const char *
arm_print_vma_and_name(Filedata * filedata,struct arm_unw_aux_info * aux,bfd_vma fn,struct absaddr addr)8347 arm_print_vma_and_name (Filedata * filedata,
8348 struct arm_unw_aux_info * aux,
8349 bfd_vma fn,
8350 struct absaddr addr)
8351 {
8352 const char *procname;
8353 bfd_vma sym_offset;
8354
8355 if (addr.section == SHN_UNDEF)
8356 addr.offset = fn;
8357
8358 find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
8359 aux->strtab_size, addr, &procname,
8360 &sym_offset);
8361
8362 print_vma (fn, PREFIX_HEX);
8363
8364 if (procname)
8365 {
8366 fputs (" <", stdout);
8367 fputs (procname, stdout);
8368
8369 if (sym_offset)
8370 printf ("+0x%lx", (unsigned long) sym_offset);
8371 fputc ('>', stdout);
8372 }
8373
8374 return procname;
8375 }
8376
8377 static void
arm_free_section(struct arm_section * arm_sec)8378 arm_free_section (struct arm_section *arm_sec)
8379 {
8380 if (arm_sec->data != NULL)
8381 free (arm_sec->data);
8382
8383 if (arm_sec->rela != NULL)
8384 free (arm_sec->rela);
8385 }
8386
8387 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8388 cached section and install SEC instead.
8389 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8390 and return its valued in * WORDP, relocating if necessary.
8391 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8392 relocation's offset in ADDR.
8393 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8394 into the string table of the symbol associated with the reloc. If no
8395 reloc was applied store -1 there.
8396 5) Return TRUE upon success, FALSE otherwise. */
8397
8398 static bfd_boolean
get_unwind_section_word(Filedata * filedata,struct arm_unw_aux_info * aux,struct arm_section * arm_sec,Elf_Internal_Shdr * sec,bfd_vma word_offset,unsigned int * wordp,struct absaddr * addr,bfd_vma * sym_name)8399 get_unwind_section_word (Filedata * filedata,
8400 struct arm_unw_aux_info * aux,
8401 struct arm_section * arm_sec,
8402 Elf_Internal_Shdr * sec,
8403 bfd_vma word_offset,
8404 unsigned int * wordp,
8405 struct absaddr * addr,
8406 bfd_vma * sym_name)
8407 {
8408 Elf_Internal_Rela *rp;
8409 Elf_Internal_Sym *sym;
8410 const char * relname;
8411 unsigned int word;
8412 bfd_boolean wrapped;
8413
8414 if (sec == NULL || arm_sec == NULL)
8415 return FALSE;
8416
8417 addr->section = SHN_UNDEF;
8418 addr->offset = 0;
8419
8420 if (sym_name != NULL)
8421 *sym_name = (bfd_vma) -1;
8422
8423 /* If necessary, update the section cache. */
8424 if (sec != arm_sec->sec)
8425 {
8426 Elf_Internal_Shdr *relsec;
8427
8428 arm_free_section (arm_sec);
8429
8430 arm_sec->sec = sec;
8431 arm_sec->data = get_data (NULL, aux->filedata, sec->sh_offset, 1,
8432 sec->sh_size, _("unwind data"));
8433 arm_sec->rela = NULL;
8434 arm_sec->nrelas = 0;
8435
8436 for (relsec = filedata->section_headers;
8437 relsec < filedata->section_headers + filedata->file_header.e_shnum;
8438 ++relsec)
8439 {
8440 if (relsec->sh_info >= filedata->file_header.e_shnum
8441 || filedata->section_headers + relsec->sh_info != sec
8442 /* PR 15745: Check the section type as well. */
8443 || (relsec->sh_type != SHT_REL
8444 && relsec->sh_type != SHT_RELA))
8445 continue;
8446
8447 arm_sec->rel_type = relsec->sh_type;
8448 if (relsec->sh_type == SHT_REL)
8449 {
8450 if (!slurp_rel_relocs (aux->filedata, relsec->sh_offset,
8451 relsec->sh_size,
8452 & arm_sec->rela, & arm_sec->nrelas))
8453 return FALSE;
8454 }
8455 else /* relsec->sh_type == SHT_RELA */
8456 {
8457 if (!slurp_rela_relocs (aux->filedata, relsec->sh_offset,
8458 relsec->sh_size,
8459 & arm_sec->rela, & arm_sec->nrelas))
8460 return FALSE;
8461 }
8462 break;
8463 }
8464
8465 arm_sec->next_rela = arm_sec->rela;
8466 }
8467
8468 /* If there is no unwind data we can do nothing. */
8469 if (arm_sec->data == NULL)
8470 return FALSE;
8471
8472 /* If the offset is invalid then fail. */
8473 if (/* PR 21343 *//* PR 18879 */
8474 sec->sh_size < 4
8475 || word_offset > (sec->sh_size - 4)
8476 || ((bfd_signed_vma) word_offset) < 0)
8477 return FALSE;
8478
8479 /* Get the word at the required offset. */
8480 word = byte_get (arm_sec->data + word_offset, 4);
8481
8482 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8483 if (arm_sec->rela == NULL)
8484 {
8485 * wordp = word;
8486 return TRUE;
8487 }
8488
8489 /* Look through the relocs to find the one that applies to the provided offset. */
8490 wrapped = FALSE;
8491 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8492 {
8493 bfd_vma prelval, offset;
8494
8495 if (rp->r_offset > word_offset && !wrapped)
8496 {
8497 rp = arm_sec->rela;
8498 wrapped = TRUE;
8499 }
8500 if (rp->r_offset > word_offset)
8501 break;
8502
8503 if (rp->r_offset & 3)
8504 {
8505 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8506 (unsigned long) rp->r_offset);
8507 continue;
8508 }
8509
8510 if (rp->r_offset < word_offset)
8511 continue;
8512
8513 /* PR 17531: file: 027-161405-0.004 */
8514 if (aux->symtab == NULL)
8515 continue;
8516
8517 if (arm_sec->rel_type == SHT_REL)
8518 {
8519 offset = word & 0x7fffffff;
8520 if (offset & 0x40000000)
8521 offset |= ~ (bfd_vma) 0x7fffffff;
8522 }
8523 else if (arm_sec->rel_type == SHT_RELA)
8524 offset = rp->r_addend;
8525 else
8526 {
8527 error (_("Unknown section relocation type %d encountered\n"),
8528 arm_sec->rel_type);
8529 break;
8530 }
8531
8532 /* PR 17531 file: 027-1241568-0.004. */
8533 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8534 {
8535 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8536 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8537 break;
8538 }
8539
8540 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8541 offset += sym->st_value;
8542 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8543
8544 /* Check that we are processing the expected reloc type. */
8545 if (filedata->file_header.e_machine == EM_ARM)
8546 {
8547 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8548 if (relname == NULL)
8549 {
8550 warn (_("Skipping unknown ARM relocation type: %d\n"),
8551 (int) ELF32_R_TYPE (rp->r_info));
8552 continue;
8553 }
8554
8555 if (streq (relname, "R_ARM_NONE"))
8556 continue;
8557
8558 if (! streq (relname, "R_ARM_PREL31"))
8559 {
8560 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8561 continue;
8562 }
8563 }
8564 else if (filedata->file_header.e_machine == EM_TI_C6000)
8565 {
8566 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8567 if (relname == NULL)
8568 {
8569 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8570 (int) ELF32_R_TYPE (rp->r_info));
8571 continue;
8572 }
8573
8574 if (streq (relname, "R_C6000_NONE"))
8575 continue;
8576
8577 if (! streq (relname, "R_C6000_PREL31"))
8578 {
8579 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8580 continue;
8581 }
8582
8583 prelval >>= 1;
8584 }
8585 else
8586 {
8587 /* This function currently only supports ARM and TI unwinders. */
8588 warn (_("Only TI and ARM unwinders are currently supported\n"));
8589 break;
8590 }
8591
8592 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8593 addr->section = sym->st_shndx;
8594 addr->offset = offset;
8595
8596 if (sym_name)
8597 * sym_name = sym->st_name;
8598 break;
8599 }
8600
8601 *wordp = word;
8602 arm_sec->next_rela = rp;
8603
8604 return TRUE;
8605 }
8606
8607 static const char *tic6x_unwind_regnames[16] =
8608 {
8609 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8610 "A14", "A13", "A12", "A11", "A10",
8611 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8612 };
8613
8614 static void
decode_tic6x_unwind_regmask(unsigned int mask)8615 decode_tic6x_unwind_regmask (unsigned int mask)
8616 {
8617 int i;
8618
8619 for (i = 12; mask; mask >>= 1, i--)
8620 {
8621 if (mask & 1)
8622 {
8623 fputs (tic6x_unwind_regnames[i], stdout);
8624 if (mask > 1)
8625 fputs (", ", stdout);
8626 }
8627 }
8628 }
8629
8630 #define ADVANCE \
8631 if (remaining == 0 && more_words) \
8632 { \
8633 data_offset += 4; \
8634 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8635 data_offset, & word, & addr, NULL)) \
8636 return FALSE; \
8637 remaining = 4; \
8638 more_words--; \
8639 } \
8640
8641 #define GET_OP(OP) \
8642 ADVANCE; \
8643 if (remaining) \
8644 { \
8645 remaining--; \
8646 (OP) = word >> 24; \
8647 word <<= 8; \
8648 } \
8649 else \
8650 { \
8651 printf (_("[Truncated opcode]\n")); \
8652 return FALSE; \
8653 } \
8654 printf ("0x%02x ", OP)
8655
8656 static bfd_boolean
decode_arm_unwind_bytecode(Filedata * filedata,struct arm_unw_aux_info * aux,unsigned int word,unsigned int remaining,unsigned int more_words,bfd_vma data_offset,Elf_Internal_Shdr * data_sec,struct arm_section * data_arm_sec)8657 decode_arm_unwind_bytecode (Filedata * filedata,
8658 struct arm_unw_aux_info * aux,
8659 unsigned int word,
8660 unsigned int remaining,
8661 unsigned int more_words,
8662 bfd_vma data_offset,
8663 Elf_Internal_Shdr * data_sec,
8664 struct arm_section * data_arm_sec)
8665 {
8666 struct absaddr addr;
8667 bfd_boolean res = TRUE;
8668
8669 /* Decode the unwinding instructions. */
8670 while (1)
8671 {
8672 unsigned int op, op2;
8673
8674 ADVANCE;
8675 if (remaining == 0)
8676 break;
8677 remaining--;
8678 op = word >> 24;
8679 word <<= 8;
8680
8681 printf (" 0x%02x ", op);
8682
8683 if ((op & 0xc0) == 0x00)
8684 {
8685 int offset = ((op & 0x3f) << 2) + 4;
8686
8687 printf (" vsp = vsp + %d", offset);
8688 }
8689 else if ((op & 0xc0) == 0x40)
8690 {
8691 int offset = ((op & 0x3f) << 2) + 4;
8692
8693 printf (" vsp = vsp - %d", offset);
8694 }
8695 else if ((op & 0xf0) == 0x80)
8696 {
8697 GET_OP (op2);
8698 if (op == 0x80 && op2 == 0)
8699 printf (_("Refuse to unwind"));
8700 else
8701 {
8702 unsigned int mask = ((op & 0x0f) << 8) | op2;
8703 bfd_boolean first = TRUE;
8704 int i;
8705
8706 printf ("pop {");
8707 for (i = 0; i < 12; i++)
8708 if (mask & (1 << i))
8709 {
8710 if (first)
8711 first = FALSE;
8712 else
8713 printf (", ");
8714 printf ("r%d", 4 + i);
8715 }
8716 printf ("}");
8717 }
8718 }
8719 else if ((op & 0xf0) == 0x90)
8720 {
8721 if (op == 0x9d || op == 0x9f)
8722 printf (_(" [Reserved]"));
8723 else
8724 printf (" vsp = r%d", op & 0x0f);
8725 }
8726 else if ((op & 0xf0) == 0xa0)
8727 {
8728 int end = 4 + (op & 0x07);
8729 bfd_boolean first = TRUE;
8730 int i;
8731
8732 printf (" pop {");
8733 for (i = 4; i <= end; i++)
8734 {
8735 if (first)
8736 first = FALSE;
8737 else
8738 printf (", ");
8739 printf ("r%d", i);
8740 }
8741 if (op & 0x08)
8742 {
8743 if (!first)
8744 printf (", ");
8745 printf ("r14");
8746 }
8747 printf ("}");
8748 }
8749 else if (op == 0xb0)
8750 printf (_(" finish"));
8751 else if (op == 0xb1)
8752 {
8753 GET_OP (op2);
8754 if (op2 == 0 || (op2 & 0xf0) != 0)
8755 printf (_("[Spare]"));
8756 else
8757 {
8758 unsigned int mask = op2 & 0x0f;
8759 bfd_boolean first = TRUE;
8760 int i;
8761
8762 printf ("pop {");
8763 for (i = 0; i < 12; i++)
8764 if (mask & (1 << i))
8765 {
8766 if (first)
8767 first = FALSE;
8768 else
8769 printf (", ");
8770 printf ("r%d", i);
8771 }
8772 printf ("}");
8773 }
8774 }
8775 else if (op == 0xb2)
8776 {
8777 unsigned char buf[9];
8778 unsigned int i, len;
8779 unsigned long offset;
8780
8781 for (i = 0; i < sizeof (buf); i++)
8782 {
8783 GET_OP (buf[i]);
8784 if ((buf[i] & 0x80) == 0)
8785 break;
8786 }
8787 if (i == sizeof (buf))
8788 {
8789 error (_("corrupt change to vsp"));
8790 res = FALSE;
8791 }
8792 else
8793 {
8794 offset = read_leb128 (buf, buf + i + 1, FALSE, &len, NULL);
8795 assert (len == i + 1);
8796 offset = offset * 4 + 0x204;
8797 printf ("vsp = vsp + %ld", offset);
8798 }
8799 }
8800 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8801 {
8802 unsigned int first, last;
8803
8804 GET_OP (op2);
8805 first = op2 >> 4;
8806 last = op2 & 0x0f;
8807 if (op == 0xc8)
8808 first = first + 16;
8809 printf ("pop {D%d", first);
8810 if (last)
8811 printf ("-D%d", first + last);
8812 printf ("}");
8813 }
8814 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8815 {
8816 unsigned int count = op & 0x07;
8817
8818 printf ("pop {D8");
8819 if (count)
8820 printf ("-D%d", 8 + count);
8821 printf ("}");
8822 }
8823 else if (op >= 0xc0 && op <= 0xc5)
8824 {
8825 unsigned int count = op & 0x07;
8826
8827 printf (" pop {wR10");
8828 if (count)
8829 printf ("-wR%d", 10 + count);
8830 printf ("}");
8831 }
8832 else if (op == 0xc6)
8833 {
8834 unsigned int first, last;
8835
8836 GET_OP (op2);
8837 first = op2 >> 4;
8838 last = op2 & 0x0f;
8839 printf ("pop {wR%d", first);
8840 if (last)
8841 printf ("-wR%d", first + last);
8842 printf ("}");
8843 }
8844 else if (op == 0xc7)
8845 {
8846 GET_OP (op2);
8847 if (op2 == 0 || (op2 & 0xf0) != 0)
8848 printf (_("[Spare]"));
8849 else
8850 {
8851 unsigned int mask = op2 & 0x0f;
8852 bfd_boolean first = TRUE;
8853 int i;
8854
8855 printf ("pop {");
8856 for (i = 0; i < 4; i++)
8857 if (mask & (1 << i))
8858 {
8859 if (first)
8860 first = FALSE;
8861 else
8862 printf (", ");
8863 printf ("wCGR%d", i);
8864 }
8865 printf ("}");
8866 }
8867 }
8868 else
8869 {
8870 printf (_(" [unsupported opcode]"));
8871 res = FALSE;
8872 }
8873
8874 printf ("\n");
8875 }
8876
8877 return res;
8878 }
8879
8880 static bfd_boolean
decode_tic6x_unwind_bytecode(Filedata * filedata,struct arm_unw_aux_info * aux,unsigned int word,unsigned int remaining,unsigned int more_words,bfd_vma data_offset,Elf_Internal_Shdr * data_sec,struct arm_section * data_arm_sec)8881 decode_tic6x_unwind_bytecode (Filedata * filedata,
8882 struct arm_unw_aux_info * aux,
8883 unsigned int word,
8884 unsigned int remaining,
8885 unsigned int more_words,
8886 bfd_vma data_offset,
8887 Elf_Internal_Shdr * data_sec,
8888 struct arm_section * data_arm_sec)
8889 {
8890 struct absaddr addr;
8891
8892 /* Decode the unwinding instructions. */
8893 while (1)
8894 {
8895 unsigned int op, op2;
8896
8897 ADVANCE;
8898 if (remaining == 0)
8899 break;
8900 remaining--;
8901 op = word >> 24;
8902 word <<= 8;
8903
8904 printf (" 0x%02x ", op);
8905
8906 if ((op & 0xc0) == 0x00)
8907 {
8908 int offset = ((op & 0x3f) << 3) + 8;
8909 printf (" sp = sp + %d", offset);
8910 }
8911 else if ((op & 0xc0) == 0x80)
8912 {
8913 GET_OP (op2);
8914 if (op == 0x80 && op2 == 0)
8915 printf (_("Refuse to unwind"));
8916 else
8917 {
8918 unsigned int mask = ((op & 0x1f) << 8) | op2;
8919 if (op & 0x20)
8920 printf ("pop compact {");
8921 else
8922 printf ("pop {");
8923
8924 decode_tic6x_unwind_regmask (mask);
8925 printf("}");
8926 }
8927 }
8928 else if ((op & 0xf0) == 0xc0)
8929 {
8930 unsigned int reg;
8931 unsigned int nregs;
8932 unsigned int i;
8933 const char *name;
8934 struct
8935 {
8936 unsigned int offset;
8937 unsigned int reg;
8938 } regpos[16];
8939
8940 /* Scan entire instruction first so that GET_OP output is not
8941 interleaved with disassembly. */
8942 nregs = 0;
8943 for (i = 0; nregs < (op & 0xf); i++)
8944 {
8945 GET_OP (op2);
8946 reg = op2 >> 4;
8947 if (reg != 0xf)
8948 {
8949 regpos[nregs].offset = i * 2;
8950 regpos[nregs].reg = reg;
8951 nregs++;
8952 }
8953
8954 reg = op2 & 0xf;
8955 if (reg != 0xf)
8956 {
8957 regpos[nregs].offset = i * 2 + 1;
8958 regpos[nregs].reg = reg;
8959 nregs++;
8960 }
8961 }
8962
8963 printf (_("pop frame {"));
8964 if (nregs == 0)
8965 {
8966 printf (_("*corrupt* - no registers specified"));
8967 }
8968 else
8969 {
8970 reg = nregs - 1;
8971 for (i = i * 2; i > 0; i--)
8972 {
8973 if (regpos[reg].offset == i - 1)
8974 {
8975 name = tic6x_unwind_regnames[regpos[reg].reg];
8976 if (reg > 0)
8977 reg--;
8978 }
8979 else
8980 name = _("[pad]");
8981
8982 fputs (name, stdout);
8983 if (i > 1)
8984 printf (", ");
8985 }
8986 }
8987
8988 printf ("}");
8989 }
8990 else if (op == 0xd0)
8991 printf (" MOV FP, SP");
8992 else if (op == 0xd1)
8993 printf (" __c6xabi_pop_rts");
8994 else if (op == 0xd2)
8995 {
8996 unsigned char buf[9];
8997 unsigned int i, len;
8998 unsigned long offset;
8999
9000 for (i = 0; i < sizeof (buf); i++)
9001 {
9002 GET_OP (buf[i]);
9003 if ((buf[i] & 0x80) == 0)
9004 break;
9005 }
9006 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
9007 if (i == sizeof (buf))
9008 {
9009 warn (_("Corrupt stack pointer adjustment detected\n"));
9010 return FALSE;
9011 }
9012
9013 offset = read_leb128 (buf, buf + i + 1, FALSE, &len, NULL);
9014 assert (len == i + 1);
9015 offset = offset * 8 + 0x408;
9016 printf (_("sp = sp + %ld"), offset);
9017 }
9018 else if ((op & 0xf0) == 0xe0)
9019 {
9020 if ((op & 0x0f) == 7)
9021 printf (" RETURN");
9022 else
9023 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
9024 }
9025 else
9026 {
9027 printf (_(" [unsupported opcode]"));
9028 }
9029 putchar ('\n');
9030 }
9031
9032 return TRUE;
9033 }
9034
9035 static bfd_vma
arm_expand_prel31(Filedata * filedata,bfd_vma word,bfd_vma where)9036 arm_expand_prel31 (Filedata * filedata, bfd_vma word, bfd_vma where)
9037 {
9038 bfd_vma offset;
9039
9040 offset = word & 0x7fffffff;
9041 if (offset & 0x40000000)
9042 offset |= ~ (bfd_vma) 0x7fffffff;
9043
9044 if (filedata->file_header.e_machine == EM_TI_C6000)
9045 offset <<= 1;
9046
9047 return offset + where;
9048 }
9049
9050 static bfd_boolean
decode_arm_unwind(Filedata * filedata,struct arm_unw_aux_info * aux,unsigned int word,unsigned int remaining,bfd_vma data_offset,Elf_Internal_Shdr * data_sec,struct arm_section * data_arm_sec)9051 decode_arm_unwind (Filedata * filedata,
9052 struct arm_unw_aux_info * aux,
9053 unsigned int word,
9054 unsigned int remaining,
9055 bfd_vma data_offset,
9056 Elf_Internal_Shdr * data_sec,
9057 struct arm_section * data_arm_sec)
9058 {
9059 int per_index;
9060 unsigned int more_words = 0;
9061 struct absaddr addr;
9062 bfd_vma sym_name = (bfd_vma) -1;
9063 bfd_boolean res = TRUE;
9064
9065 if (remaining == 0)
9066 {
9067 /* Fetch the first word.
9068 Note - when decoding an object file the address extracted
9069 here will always be 0. So we also pass in the sym_name
9070 parameter so that we can find the symbol associated with
9071 the personality routine. */
9072 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, data_offset,
9073 & word, & addr, & sym_name))
9074 return FALSE;
9075
9076 remaining = 4;
9077 }
9078 else
9079 {
9080 addr.section = SHN_UNDEF;
9081 addr.offset = 0;
9082 }
9083
9084 if ((word & 0x80000000) == 0)
9085 {
9086 /* Expand prel31 for personality routine. */
9087 bfd_vma fn;
9088 const char *procname;
9089
9090 fn = arm_expand_prel31 (filedata, word, data_sec->sh_addr + data_offset);
9091 printf (_(" Personality routine: "));
9092 if (fn == 0
9093 && addr.section == SHN_UNDEF && addr.offset == 0
9094 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
9095 {
9096 procname = aux->strtab + sym_name;
9097 print_vma (fn, PREFIX_HEX);
9098 if (procname)
9099 {
9100 fputs (" <", stdout);
9101 fputs (procname, stdout);
9102 fputc ('>', stdout);
9103 }
9104 }
9105 else
9106 procname = arm_print_vma_and_name (filedata, aux, fn, addr);
9107 fputc ('\n', stdout);
9108
9109 /* The GCC personality routines use the standard compact
9110 encoding, starting with one byte giving the number of
9111 words. */
9112 if (procname != NULL
9113 && (const_strneq (procname, "__gcc_personality_v0")
9114 || const_strneq (procname, "__gxx_personality_v0")
9115 || const_strneq (procname, "__gcj_personality_v0")
9116 || const_strneq (procname, "__gnu_objc_personality_v0")))
9117 {
9118 remaining = 0;
9119 more_words = 1;
9120 ADVANCE;
9121 if (!remaining)
9122 {
9123 printf (_(" [Truncated data]\n"));
9124 return FALSE;
9125 }
9126 more_words = word >> 24;
9127 word <<= 8;
9128 remaining--;
9129 per_index = -1;
9130 }
9131 else
9132 return TRUE;
9133 }
9134 else
9135 {
9136 /* ARM EHABI Section 6.3:
9137
9138 An exception-handling table entry for the compact model looks like:
9139
9140 31 30-28 27-24 23-0
9141 -- ----- ----- ----
9142 1 0 index Data for personalityRoutine[index] */
9143
9144 if (filedata->file_header.e_machine == EM_ARM
9145 && (word & 0x70000000))
9146 {
9147 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
9148 res = FALSE;
9149 }
9150
9151 per_index = (word >> 24) & 0x7f;
9152 printf (_(" Compact model index: %d\n"), per_index);
9153 if (per_index == 0)
9154 {
9155 more_words = 0;
9156 word <<= 8;
9157 remaining--;
9158 }
9159 else if (per_index < 3)
9160 {
9161 more_words = (word >> 16) & 0xff;
9162 word <<= 16;
9163 remaining -= 2;
9164 }
9165 }
9166
9167 switch (filedata->file_header.e_machine)
9168 {
9169 case EM_ARM:
9170 if (per_index < 3)
9171 {
9172 if (! decode_arm_unwind_bytecode (filedata, aux, word, remaining, more_words,
9173 data_offset, data_sec, data_arm_sec))
9174 res = FALSE;
9175 }
9176 else
9177 {
9178 warn (_("Unknown ARM compact model index encountered\n"));
9179 printf (_(" [reserved]\n"));
9180 res = FALSE;
9181 }
9182 break;
9183
9184 case EM_TI_C6000:
9185 if (per_index < 3)
9186 {
9187 if (! decode_tic6x_unwind_bytecode (filedata, aux, word, remaining, more_words,
9188 data_offset, data_sec, data_arm_sec))
9189 res = FALSE;
9190 }
9191 else if (per_index < 5)
9192 {
9193 if (((word >> 17) & 0x7f) == 0x7f)
9194 printf (_(" Restore stack from frame pointer\n"));
9195 else
9196 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
9197 printf (_(" Registers restored: "));
9198 if (per_index == 4)
9199 printf (" (compact) ");
9200 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
9201 putchar ('\n');
9202 printf (_(" Return register: %s\n"),
9203 tic6x_unwind_regnames[word & 0xf]);
9204 }
9205 else
9206 printf (_(" [reserved (%d)]\n"), per_index);
9207 break;
9208
9209 default:
9210 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9211 filedata->file_header.e_machine);
9212 res = FALSE;
9213 }
9214
9215 /* Decode the descriptors. Not implemented. */
9216
9217 return res;
9218 }
9219
9220 static bfd_boolean
dump_arm_unwind(Filedata * filedata,struct arm_unw_aux_info * aux,Elf_Internal_Shdr * exidx_sec)9221 dump_arm_unwind (Filedata * filedata,
9222 struct arm_unw_aux_info * aux,
9223 Elf_Internal_Shdr * exidx_sec)
9224 {
9225 struct arm_section exidx_arm_sec, extab_arm_sec;
9226 unsigned int i, exidx_len;
9227 unsigned long j, nfuns;
9228 bfd_boolean res = TRUE;
9229
9230 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
9231 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
9232 exidx_len = exidx_sec->sh_size / 8;
9233
9234 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
9235 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
9236 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
9237 aux->funtab[nfuns++] = aux->symtab[j];
9238 aux->nfuns = nfuns;
9239 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
9240
9241 for (i = 0; i < exidx_len; i++)
9242 {
9243 unsigned int exidx_fn, exidx_entry;
9244 struct absaddr fn_addr, entry_addr;
9245 bfd_vma fn;
9246
9247 fputc ('\n', stdout);
9248
9249 if (! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9250 8 * i, & exidx_fn, & fn_addr, NULL)
9251 || ! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9252 8 * i + 4, & exidx_entry, & entry_addr, NULL))
9253 {
9254 free (aux->funtab);
9255 arm_free_section (& exidx_arm_sec);
9256 arm_free_section (& extab_arm_sec);
9257 return FALSE;
9258 }
9259
9260 /* ARM EHABI, Section 5:
9261 An index table entry consists of 2 words.
9262 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9263 if (exidx_fn & 0x80000000)
9264 {
9265 warn (_("corrupt index table entry: %x\n"), exidx_fn);
9266 res = FALSE;
9267 }
9268
9269 fn = arm_expand_prel31 (filedata, exidx_fn, exidx_sec->sh_addr + 8 * i);
9270
9271 arm_print_vma_and_name (filedata, aux, fn, fn_addr);
9272 fputs (": ", stdout);
9273
9274 if (exidx_entry == 1)
9275 {
9276 print_vma (exidx_entry, PREFIX_HEX);
9277 fputs (" [cantunwind]\n", stdout);
9278 }
9279 else if (exidx_entry & 0x80000000)
9280 {
9281 print_vma (exidx_entry, PREFIX_HEX);
9282 fputc ('\n', stdout);
9283 decode_arm_unwind (filedata, aux, exidx_entry, 4, 0, NULL, NULL);
9284 }
9285 else
9286 {
9287 bfd_vma table, table_offset = 0;
9288 Elf_Internal_Shdr *table_sec;
9289
9290 fputs ("@", stdout);
9291 table = arm_expand_prel31 (filedata, exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
9292 print_vma (table, PREFIX_HEX);
9293 printf ("\n");
9294
9295 /* Locate the matching .ARM.extab. */
9296 if (entry_addr.section != SHN_UNDEF
9297 && entry_addr.section < filedata->file_header.e_shnum)
9298 {
9299 table_sec = filedata->section_headers + entry_addr.section;
9300 table_offset = entry_addr.offset;
9301 /* PR 18879 */
9302 if (table_offset > table_sec->sh_size
9303 || ((bfd_signed_vma) table_offset) < 0)
9304 {
9305 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9306 (unsigned long) table_offset,
9307 printable_section_name (filedata, table_sec));
9308 res = FALSE;
9309 continue;
9310 }
9311 }
9312 else
9313 {
9314 table_sec = find_section_by_address (filedata, table);
9315 if (table_sec != NULL)
9316 table_offset = table - table_sec->sh_addr;
9317 }
9318
9319 if (table_sec == NULL)
9320 {
9321 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9322 (unsigned long) table);
9323 res = FALSE;
9324 continue;
9325 }
9326
9327 if (! decode_arm_unwind (filedata, aux, 0, 0, table_offset, table_sec,
9328 &extab_arm_sec))
9329 res = FALSE;
9330 }
9331 }
9332
9333 printf ("\n");
9334
9335 free (aux->funtab);
9336 arm_free_section (&exidx_arm_sec);
9337 arm_free_section (&extab_arm_sec);
9338
9339 return res;
9340 }
9341
9342 /* Used for both ARM and C6X unwinding tables. */
9343
9344 static bfd_boolean
arm_process_unwind(Filedata * filedata)9345 arm_process_unwind (Filedata * filedata)
9346 {
9347 struct arm_unw_aux_info aux;
9348 Elf_Internal_Shdr *unwsec = NULL;
9349 Elf_Internal_Shdr *strsec;
9350 Elf_Internal_Shdr *sec;
9351 unsigned long i;
9352 unsigned int sec_type;
9353 bfd_boolean res = TRUE;
9354
9355 switch (filedata->file_header.e_machine)
9356 {
9357 case EM_ARM:
9358 sec_type = SHT_ARM_EXIDX;
9359 break;
9360
9361 case EM_TI_C6000:
9362 sec_type = SHT_C6000_UNWIND;
9363 break;
9364
9365 default:
9366 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9367 filedata->file_header.e_machine);
9368 return FALSE;
9369 }
9370
9371 if (filedata->string_table == NULL)
9372 return FALSE;
9373
9374 memset (& aux, 0, sizeof (aux));
9375 aux.filedata = filedata;
9376
9377 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9378 {
9379 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < filedata->file_header.e_shnum)
9380 {
9381 aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
9382
9383 strsec = filedata->section_headers + sec->sh_link;
9384
9385 /* PR binutils/17531 file: 011-12666-0.004. */
9386 if (aux.strtab != NULL)
9387 {
9388 error (_("Multiple string tables found in file.\n"));
9389 free (aux.strtab);
9390 res = FALSE;
9391 }
9392 aux.strtab = get_data (NULL, filedata, strsec->sh_offset,
9393 1, strsec->sh_size, _("string table"));
9394 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
9395 }
9396 else if (sec->sh_type == sec_type)
9397 unwsec = sec;
9398 }
9399
9400 if (unwsec == NULL)
9401 printf (_("\nThere are no unwind sections in this file.\n"));
9402 else
9403 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9404 {
9405 if (sec->sh_type == sec_type)
9406 {
9407 unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size);
9408 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9409 "contains %lu entry:\n",
9410 "\nUnwind section '%s' at offset 0x%lx "
9411 "contains %lu entries:\n",
9412 num_unwind),
9413 printable_section_name (filedata, sec),
9414 (unsigned long) sec->sh_offset,
9415 num_unwind);
9416
9417 if (! dump_arm_unwind (filedata, &aux, sec))
9418 res = FALSE;
9419 }
9420 }
9421
9422 if (aux.symtab)
9423 free (aux.symtab);
9424 if (aux.strtab)
9425 free ((char *) aux.strtab);
9426
9427 return res;
9428 }
9429
9430 static bfd_boolean
process_unwind(Filedata * filedata)9431 process_unwind (Filedata * filedata)
9432 {
9433 struct unwind_handler
9434 {
9435 unsigned int machtype;
9436 bfd_boolean (* handler)(Filedata *);
9437 } handlers[] =
9438 {
9439 { EM_ARM, arm_process_unwind },
9440 { EM_IA_64, ia64_process_unwind },
9441 { EM_PARISC, hppa_process_unwind },
9442 { EM_TI_C6000, arm_process_unwind },
9443 { 0, NULL }
9444 };
9445 int i;
9446
9447 if (!do_unwind)
9448 return TRUE;
9449
9450 for (i = 0; handlers[i].handler != NULL; i++)
9451 if (filedata->file_header.e_machine == handlers[i].machtype)
9452 return handlers[i].handler (filedata);
9453
9454 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9455 get_machine_name (filedata->file_header.e_machine));
9456 return TRUE;
9457 }
9458
9459 static void
dynamic_section_aarch64_val(Elf_Internal_Dyn * entry)9460 dynamic_section_aarch64_val (Elf_Internal_Dyn * entry)
9461 {
9462 switch (entry->d_tag)
9463 {
9464 case DT_AARCH64_BTI_PLT:
9465 case DT_AARCH64_PAC_PLT:
9466 break;
9467 default:
9468 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9469 break;
9470 }
9471 putchar ('\n');
9472 }
9473
9474 static void
dynamic_section_mips_val(Elf_Internal_Dyn * entry)9475 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
9476 {
9477 switch (entry->d_tag)
9478 {
9479 case DT_MIPS_FLAGS:
9480 if (entry->d_un.d_val == 0)
9481 printf (_("NONE"));
9482 else
9483 {
9484 static const char * opts[] =
9485 {
9486 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9487 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9488 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9489 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9490 "RLD_ORDER_SAFE"
9491 };
9492 unsigned int cnt;
9493 bfd_boolean first = TRUE;
9494
9495 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9496 if (entry->d_un.d_val & (1 << cnt))
9497 {
9498 printf ("%s%s", first ? "" : " ", opts[cnt]);
9499 first = FALSE;
9500 }
9501 }
9502 break;
9503
9504 case DT_MIPS_IVERSION:
9505 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9506 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
9507 else
9508 {
9509 char buf[40];
9510 sprintf_vma (buf, entry->d_un.d_ptr);
9511 /* Note: coded this way so that there is a single string for translation. */
9512 printf (_("<corrupt: %s>"), buf);
9513 }
9514 break;
9515
9516 case DT_MIPS_TIME_STAMP:
9517 {
9518 char timebuf[128];
9519 struct tm * tmp;
9520 time_t atime = entry->d_un.d_val;
9521
9522 tmp = gmtime (&atime);
9523 /* PR 17531: file: 6accc532. */
9524 if (tmp == NULL)
9525 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9526 else
9527 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9528 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9529 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9530 printf (_("Time Stamp: %s"), timebuf);
9531 }
9532 break;
9533
9534 case DT_MIPS_RLD_VERSION:
9535 case DT_MIPS_LOCAL_GOTNO:
9536 case DT_MIPS_CONFLICTNO:
9537 case DT_MIPS_LIBLISTNO:
9538 case DT_MIPS_SYMTABNO:
9539 case DT_MIPS_UNREFEXTNO:
9540 case DT_MIPS_HIPAGENO:
9541 case DT_MIPS_DELTA_CLASS_NO:
9542 case DT_MIPS_DELTA_INSTANCE_NO:
9543 case DT_MIPS_DELTA_RELOC_NO:
9544 case DT_MIPS_DELTA_SYM_NO:
9545 case DT_MIPS_DELTA_CLASSSYM_NO:
9546 case DT_MIPS_COMPACT_SIZE:
9547 print_vma (entry->d_un.d_val, DEC);
9548 break;
9549
9550 case DT_MIPS_XHASH:
9551 dynamic_info_DT_MIPS_XHASH = entry->d_un.d_val;
9552 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9553 /* Falls through. */
9554
9555 default:
9556 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9557 }
9558 putchar ('\n');
9559 }
9560
9561 static void
dynamic_section_parisc_val(Elf_Internal_Dyn * entry)9562 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9563 {
9564 switch (entry->d_tag)
9565 {
9566 case DT_HP_DLD_FLAGS:
9567 {
9568 static struct
9569 {
9570 long int bit;
9571 const char * str;
9572 }
9573 flags[] =
9574 {
9575 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9576 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9577 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9578 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9579 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9580 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9581 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9582 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9583 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9584 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9585 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9586 { DT_HP_GST, "HP_GST" },
9587 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9588 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9589 { DT_HP_NODELETE, "HP_NODELETE" },
9590 { DT_HP_GROUP, "HP_GROUP" },
9591 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9592 };
9593 bfd_boolean first = TRUE;
9594 size_t cnt;
9595 bfd_vma val = entry->d_un.d_val;
9596
9597 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9598 if (val & flags[cnt].bit)
9599 {
9600 if (! first)
9601 putchar (' ');
9602 fputs (flags[cnt].str, stdout);
9603 first = FALSE;
9604 val ^= flags[cnt].bit;
9605 }
9606
9607 if (val != 0 || first)
9608 {
9609 if (! first)
9610 putchar (' ');
9611 print_vma (val, HEX);
9612 }
9613 }
9614 break;
9615
9616 default:
9617 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9618 break;
9619 }
9620 putchar ('\n');
9621 }
9622
9623 #ifdef BFD64
9624
9625 /* VMS vs Unix time offset and factor. */
9626
9627 #define VMS_EPOCH_OFFSET 35067168000000000LL
9628 #define VMS_GRANULARITY_FACTOR 10000000
9629
9630 /* Display a VMS time in a human readable format. */
9631
9632 static void
print_vms_time(bfd_int64_t vmstime)9633 print_vms_time (bfd_int64_t vmstime)
9634 {
9635 struct tm *tm;
9636 time_t unxtime;
9637
9638 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9639 tm = gmtime (&unxtime);
9640 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9641 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9642 tm->tm_hour, tm->tm_min, tm->tm_sec);
9643 }
9644 #endif /* BFD64 */
9645
9646 static void
dynamic_section_ia64_val(Elf_Internal_Dyn * entry)9647 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9648 {
9649 switch (entry->d_tag)
9650 {
9651 case DT_IA_64_PLT_RESERVE:
9652 /* First 3 slots reserved. */
9653 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9654 printf (" -- ");
9655 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9656 break;
9657
9658 case DT_IA_64_VMS_LINKTIME:
9659 #ifdef BFD64
9660 print_vms_time (entry->d_un.d_val);
9661 #endif
9662 break;
9663
9664 case DT_IA_64_VMS_LNKFLAGS:
9665 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9666 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9667 printf (" CALL_DEBUG");
9668 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9669 printf (" NOP0BUFS");
9670 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9671 printf (" P0IMAGE");
9672 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9673 printf (" MKTHREADS");
9674 if (entry->d_un.d_val & VMS_LF_UPCALLS)
9675 printf (" UPCALLS");
9676 if (entry->d_un.d_val & VMS_LF_IMGSTA)
9677 printf (" IMGSTA");
9678 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9679 printf (" INITIALIZE");
9680 if (entry->d_un.d_val & VMS_LF_MAIN)
9681 printf (" MAIN");
9682 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9683 printf (" EXE_INIT");
9684 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9685 printf (" TBK_IN_IMG");
9686 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9687 printf (" DBG_IN_IMG");
9688 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9689 printf (" TBK_IN_DSF");
9690 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9691 printf (" DBG_IN_DSF");
9692 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9693 printf (" SIGNATURES");
9694 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9695 printf (" REL_SEG_OFF");
9696 break;
9697
9698 default:
9699 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9700 break;
9701 }
9702 putchar ('\n');
9703 }
9704
9705 static bfd_boolean
get_32bit_dynamic_section(Filedata * filedata)9706 get_32bit_dynamic_section (Filedata * filedata)
9707 {
9708 Elf32_External_Dyn * edyn;
9709 Elf32_External_Dyn * ext;
9710 Elf_Internal_Dyn * entry;
9711
9712 edyn = (Elf32_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9713 dynamic_size, _("dynamic section"));
9714 if (!edyn)
9715 return FALSE;
9716
9717 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9718 might not have the luxury of section headers. Look for the DT_NULL
9719 terminator to determine the number of entries. */
9720 for (ext = edyn, dynamic_nent = 0;
9721 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9722 ext++)
9723 {
9724 dynamic_nent++;
9725 if (BYTE_GET (ext->d_tag) == DT_NULL)
9726 break;
9727 }
9728
9729 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9730 sizeof (* entry));
9731 if (dynamic_section == NULL)
9732 {
9733 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9734 (unsigned long) dynamic_nent);
9735 free (edyn);
9736 return FALSE;
9737 }
9738
9739 for (ext = edyn, entry = dynamic_section;
9740 entry < dynamic_section + dynamic_nent;
9741 ext++, entry++)
9742 {
9743 entry->d_tag = BYTE_GET (ext->d_tag);
9744 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9745 }
9746
9747 free (edyn);
9748
9749 return TRUE;
9750 }
9751
9752 static bfd_boolean
get_64bit_dynamic_section(Filedata * filedata)9753 get_64bit_dynamic_section (Filedata * filedata)
9754 {
9755 Elf64_External_Dyn * edyn;
9756 Elf64_External_Dyn * ext;
9757 Elf_Internal_Dyn * entry;
9758
9759 /* Read in the data. */
9760 edyn = (Elf64_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9761 dynamic_size, _("dynamic section"));
9762 if (!edyn)
9763 return FALSE;
9764
9765 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9766 might not have the luxury of section headers. Look for the DT_NULL
9767 terminator to determine the number of entries. */
9768 for (ext = edyn, dynamic_nent = 0;
9769 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9770 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9771 ext++)
9772 {
9773 dynamic_nent++;
9774 if (BYTE_GET (ext->d_tag) == DT_NULL)
9775 break;
9776 }
9777
9778 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9779 sizeof (* entry));
9780 if (dynamic_section == NULL)
9781 {
9782 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9783 (unsigned long) dynamic_nent);
9784 free (edyn);
9785 return FALSE;
9786 }
9787
9788 /* Convert from external to internal formats. */
9789 for (ext = edyn, entry = dynamic_section;
9790 entry < dynamic_section + dynamic_nent;
9791 ext++, entry++)
9792 {
9793 entry->d_tag = BYTE_GET (ext->d_tag);
9794 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9795 }
9796
9797 free (edyn);
9798
9799 return TRUE;
9800 }
9801
9802 static void
print_dynamic_flags(bfd_vma flags)9803 print_dynamic_flags (bfd_vma flags)
9804 {
9805 bfd_boolean first = TRUE;
9806
9807 while (flags)
9808 {
9809 bfd_vma flag;
9810
9811 flag = flags & - flags;
9812 flags &= ~ flag;
9813
9814 if (first)
9815 first = FALSE;
9816 else
9817 putc (' ', stdout);
9818
9819 switch (flag)
9820 {
9821 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
9822 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
9823 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
9824 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
9825 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
9826 default: fputs (_("unknown"), stdout); break;
9827 }
9828 }
9829 puts ("");
9830 }
9831
9832 /* Parse and display the contents of the dynamic section. */
9833
9834 static bfd_boolean
process_dynamic_section(Filedata * filedata)9835 process_dynamic_section (Filedata * filedata)
9836 {
9837 Elf_Internal_Dyn * entry;
9838
9839 if (dynamic_size == 0)
9840 {
9841 if (do_dynamic)
9842 printf (_("\nThere is no dynamic section in this file.\n"));
9843
9844 return TRUE;
9845 }
9846
9847 if (is_32bit_elf)
9848 {
9849 if (! get_32bit_dynamic_section (filedata))
9850 return FALSE;
9851 }
9852 else
9853 {
9854 if (! get_64bit_dynamic_section (filedata))
9855 return FALSE;
9856 }
9857
9858 /* Find the appropriate symbol table. */
9859 if (dynamic_symbols == NULL)
9860 {
9861 for (entry = dynamic_section;
9862 entry < dynamic_section + dynamic_nent;
9863 ++entry)
9864 {
9865 Elf_Internal_Shdr section;
9866
9867 if (entry->d_tag != DT_SYMTAB)
9868 continue;
9869
9870 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9871
9872 /* Since we do not know how big the symbol table is,
9873 we default to reading in the entire file (!) and
9874 processing that. This is overkill, I know, but it
9875 should work. */
9876 section.sh_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9877 if ((bfd_size_type) section.sh_offset > filedata->file_size)
9878 {
9879 /* See PR 21379 for a reproducer. */
9880 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section.sh_offset);
9881 return FALSE;
9882 }
9883
9884 if (archive_file_offset != 0)
9885 section.sh_size = archive_file_size - section.sh_offset;
9886 else
9887 section.sh_size = filedata->file_size - section.sh_offset;
9888
9889 if (is_32bit_elf)
9890 section.sh_entsize = sizeof (Elf32_External_Sym);
9891 else
9892 section.sh_entsize = sizeof (Elf64_External_Sym);
9893 section.sh_name = filedata->string_table_length;
9894
9895 if (dynamic_symbols != NULL)
9896 {
9897 error (_("Multiple dynamic symbol table sections found\n"));
9898 free (dynamic_symbols);
9899 }
9900 dynamic_symbols = GET_ELF_SYMBOLS (filedata, §ion, & num_dynamic_syms);
9901 if (num_dynamic_syms < 1)
9902 {
9903 error (_("Unable to determine the number of symbols to load\n"));
9904 continue;
9905 }
9906 }
9907 }
9908
9909 /* Similarly find a string table. */
9910 if (dynamic_strings == NULL)
9911 {
9912 for (entry = dynamic_section;
9913 entry < dynamic_section + dynamic_nent;
9914 ++entry)
9915 {
9916 unsigned long offset;
9917 long str_tab_len;
9918
9919 if (entry->d_tag != DT_STRTAB)
9920 continue;
9921
9922 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9923
9924 /* Since we do not know how big the string table is,
9925 we default to reading in the entire file (!) and
9926 processing that. This is overkill, I know, but it
9927 should work. */
9928
9929 offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9930
9931 if (archive_file_offset != 0)
9932 str_tab_len = archive_file_size - offset;
9933 else
9934 str_tab_len = filedata->file_size - offset;
9935
9936 if (str_tab_len < 1)
9937 {
9938 error
9939 (_("Unable to determine the length of the dynamic string table\n"));
9940 continue;
9941 }
9942
9943 if (dynamic_strings != NULL)
9944 {
9945 error (_("Multiple dynamic string tables found\n"));
9946 free (dynamic_strings);
9947 }
9948
9949 dynamic_strings = (char *) get_data (NULL, filedata, offset, 1,
9950 str_tab_len,
9951 _("dynamic string table"));
9952 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9953 }
9954 }
9955
9956 /* And find the syminfo section if available. */
9957 if (dynamic_syminfo == NULL)
9958 {
9959 unsigned long syminsz = 0;
9960
9961 for (entry = dynamic_section;
9962 entry < dynamic_section + dynamic_nent;
9963 ++entry)
9964 {
9965 if (entry->d_tag == DT_SYMINENT)
9966 {
9967 /* Note: these braces are necessary to avoid a syntax
9968 error from the SunOS4 C compiler. */
9969 /* PR binutils/17531: A corrupt file can trigger this test.
9970 So do not use an assert, instead generate an error message. */
9971 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9972 error (_("Bad value (%d) for SYMINENT entry\n"),
9973 (int) entry->d_un.d_val);
9974 }
9975 else if (entry->d_tag == DT_SYMINSZ)
9976 syminsz = entry->d_un.d_val;
9977 else if (entry->d_tag == DT_SYMINFO)
9978 dynamic_syminfo_offset = offset_from_vma (filedata, entry->d_un.d_val,
9979 syminsz);
9980 }
9981
9982 if (dynamic_syminfo_offset != 0 && syminsz != 0)
9983 {
9984 Elf_External_Syminfo * extsyminfo;
9985 Elf_External_Syminfo * extsym;
9986 Elf_Internal_Syminfo * syminfo;
9987
9988 /* There is a syminfo section. Read the data. */
9989 extsyminfo = (Elf_External_Syminfo *)
9990 get_data (NULL, filedata, dynamic_syminfo_offset, 1, syminsz,
9991 _("symbol information"));
9992 if (!extsyminfo)
9993 return FALSE;
9994
9995 if (dynamic_syminfo != NULL)
9996 {
9997 error (_("Multiple dynamic symbol information sections found\n"));
9998 free (dynamic_syminfo);
9999 }
10000 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
10001 if (dynamic_syminfo == NULL)
10002 {
10003 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
10004 (unsigned long) syminsz);
10005 return FALSE;
10006 }
10007
10008 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
10009 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
10010 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
10011 ++syminfo, ++extsym)
10012 {
10013 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
10014 syminfo->si_flags = BYTE_GET (extsym->si_flags);
10015 }
10016
10017 free (extsyminfo);
10018 }
10019 }
10020
10021 if (do_dynamic && dynamic_addr)
10022 printf (ngettext ("\nDynamic section at offset 0x%lx "
10023 "contains %lu entry:\n",
10024 "\nDynamic section at offset 0x%lx "
10025 "contains %lu entries:\n",
10026 dynamic_nent),
10027 dynamic_addr, (unsigned long) dynamic_nent);
10028 if (do_dynamic)
10029 printf (_(" Tag Type Name/Value\n"));
10030
10031 for (entry = dynamic_section;
10032 entry < dynamic_section + dynamic_nent;
10033 entry++)
10034 {
10035 if (do_dynamic)
10036 {
10037 const char * dtype;
10038
10039 putchar (' ');
10040 print_vma (entry->d_tag, FULL_HEX);
10041 dtype = get_dynamic_type (filedata, entry->d_tag);
10042 printf (" (%s)%*s", dtype,
10043 ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
10044 }
10045
10046 switch (entry->d_tag)
10047 {
10048 case DT_FLAGS:
10049 if (do_dynamic)
10050 print_dynamic_flags (entry->d_un.d_val);
10051 break;
10052
10053 case DT_AUXILIARY:
10054 case DT_FILTER:
10055 case DT_CONFIG:
10056 case DT_DEPAUDIT:
10057 case DT_AUDIT:
10058 if (do_dynamic)
10059 {
10060 switch (entry->d_tag)
10061 {
10062 case DT_AUXILIARY:
10063 printf (_("Auxiliary library"));
10064 break;
10065
10066 case DT_FILTER:
10067 printf (_("Filter library"));
10068 break;
10069
10070 case DT_CONFIG:
10071 printf (_("Configuration file"));
10072 break;
10073
10074 case DT_DEPAUDIT:
10075 printf (_("Dependency audit library"));
10076 break;
10077
10078 case DT_AUDIT:
10079 printf (_("Audit library"));
10080 break;
10081 }
10082
10083 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
10084 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
10085 else
10086 {
10087 printf (": ");
10088 print_vma (entry->d_un.d_val, PREFIX_HEX);
10089 putchar ('\n');
10090 }
10091 }
10092 break;
10093
10094 case DT_FEATURE:
10095 if (do_dynamic)
10096 {
10097 printf (_("Flags:"));
10098
10099 if (entry->d_un.d_val == 0)
10100 printf (_(" None\n"));
10101 else
10102 {
10103 unsigned long int val = entry->d_un.d_val;
10104
10105 if (val & DTF_1_PARINIT)
10106 {
10107 printf (" PARINIT");
10108 val ^= DTF_1_PARINIT;
10109 }
10110 if (val & DTF_1_CONFEXP)
10111 {
10112 printf (" CONFEXP");
10113 val ^= DTF_1_CONFEXP;
10114 }
10115 if (val != 0)
10116 printf (" %lx", val);
10117 puts ("");
10118 }
10119 }
10120 break;
10121
10122 case DT_POSFLAG_1:
10123 if (do_dynamic)
10124 {
10125 printf (_("Flags:"));
10126
10127 if (entry->d_un.d_val == 0)
10128 printf (_(" None\n"));
10129 else
10130 {
10131 unsigned long int val = entry->d_un.d_val;
10132
10133 if (val & DF_P1_LAZYLOAD)
10134 {
10135 printf (" LAZYLOAD");
10136 val ^= DF_P1_LAZYLOAD;
10137 }
10138 if (val & DF_P1_GROUPPERM)
10139 {
10140 printf (" GROUPPERM");
10141 val ^= DF_P1_GROUPPERM;
10142 }
10143 if (val != 0)
10144 printf (" %lx", val);
10145 puts ("");
10146 }
10147 }
10148 break;
10149
10150 case DT_FLAGS_1:
10151 if (do_dynamic)
10152 {
10153 printf (_("Flags:"));
10154 if (entry->d_un.d_val == 0)
10155 printf (_(" None\n"));
10156 else
10157 {
10158 unsigned long int val = entry->d_un.d_val;
10159
10160 if (val & DF_1_NOW)
10161 {
10162 printf (" NOW");
10163 val ^= DF_1_NOW;
10164 }
10165 if (val & DF_1_GLOBAL)
10166 {
10167 printf (" GLOBAL");
10168 val ^= DF_1_GLOBAL;
10169 }
10170 if (val & DF_1_GROUP)
10171 {
10172 printf (" GROUP");
10173 val ^= DF_1_GROUP;
10174 }
10175 if (val & DF_1_NODELETE)
10176 {
10177 printf (" NODELETE");
10178 val ^= DF_1_NODELETE;
10179 }
10180 if (val & DF_1_LOADFLTR)
10181 {
10182 printf (" LOADFLTR");
10183 val ^= DF_1_LOADFLTR;
10184 }
10185 if (val & DF_1_INITFIRST)
10186 {
10187 printf (" INITFIRST");
10188 val ^= DF_1_INITFIRST;
10189 }
10190 if (val & DF_1_NOOPEN)
10191 {
10192 printf (" NOOPEN");
10193 val ^= DF_1_NOOPEN;
10194 }
10195 if (val & DF_1_ORIGIN)
10196 {
10197 printf (" ORIGIN");
10198 val ^= DF_1_ORIGIN;
10199 }
10200 if (val & DF_1_DIRECT)
10201 {
10202 printf (" DIRECT");
10203 val ^= DF_1_DIRECT;
10204 }
10205 if (val & DF_1_TRANS)
10206 {
10207 printf (" TRANS");
10208 val ^= DF_1_TRANS;
10209 }
10210 if (val & DF_1_INTERPOSE)
10211 {
10212 printf (" INTERPOSE");
10213 val ^= DF_1_INTERPOSE;
10214 }
10215 if (val & DF_1_NODEFLIB)
10216 {
10217 printf (" NODEFLIB");
10218 val ^= DF_1_NODEFLIB;
10219 }
10220 if (val & DF_1_NODUMP)
10221 {
10222 printf (" NODUMP");
10223 val ^= DF_1_NODUMP;
10224 }
10225 if (val & DF_1_CONFALT)
10226 {
10227 printf (" CONFALT");
10228 val ^= DF_1_CONFALT;
10229 }
10230 if (val & DF_1_ENDFILTEE)
10231 {
10232 printf (" ENDFILTEE");
10233 val ^= DF_1_ENDFILTEE;
10234 }
10235 if (val & DF_1_DISPRELDNE)
10236 {
10237 printf (" DISPRELDNE");
10238 val ^= DF_1_DISPRELDNE;
10239 }
10240 if (val & DF_1_DISPRELPND)
10241 {
10242 printf (" DISPRELPND");
10243 val ^= DF_1_DISPRELPND;
10244 }
10245 if (val & DF_1_NODIRECT)
10246 {
10247 printf (" NODIRECT");
10248 val ^= DF_1_NODIRECT;
10249 }
10250 if (val & DF_1_IGNMULDEF)
10251 {
10252 printf (" IGNMULDEF");
10253 val ^= DF_1_IGNMULDEF;
10254 }
10255 if (val & DF_1_NOKSYMS)
10256 {
10257 printf (" NOKSYMS");
10258 val ^= DF_1_NOKSYMS;
10259 }
10260 if (val & DF_1_NOHDR)
10261 {
10262 printf (" NOHDR");
10263 val ^= DF_1_NOHDR;
10264 }
10265 if (val & DF_1_EDITED)
10266 {
10267 printf (" EDITED");
10268 val ^= DF_1_EDITED;
10269 }
10270 if (val & DF_1_NORELOC)
10271 {
10272 printf (" NORELOC");
10273 val ^= DF_1_NORELOC;
10274 }
10275 if (val & DF_1_SYMINTPOSE)
10276 {
10277 printf (" SYMINTPOSE");
10278 val ^= DF_1_SYMINTPOSE;
10279 }
10280 if (val & DF_1_GLOBAUDIT)
10281 {
10282 printf (" GLOBAUDIT");
10283 val ^= DF_1_GLOBAUDIT;
10284 }
10285 if (val & DF_1_SINGLETON)
10286 {
10287 printf (" SINGLETON");
10288 val ^= DF_1_SINGLETON;
10289 }
10290 if (val & DF_1_STUB)
10291 {
10292 printf (" STUB");
10293 val ^= DF_1_STUB;
10294 }
10295 if (val & DF_1_PIE)
10296 {
10297 printf (" PIE");
10298 val ^= DF_1_PIE;
10299 }
10300 if (val & DF_1_KMOD)
10301 {
10302 printf (" KMOD");
10303 val ^= DF_1_KMOD;
10304 }
10305 if (val & DF_1_WEAKFILTER)
10306 {
10307 printf (" WEAKFILTER");
10308 val ^= DF_1_WEAKFILTER;
10309 }
10310 if (val & DF_1_NOCOMMON)
10311 {
10312 printf (" NOCOMMON");
10313 val ^= DF_1_NOCOMMON;
10314 }
10315 if (val != 0)
10316 printf (" %lx", val);
10317 puts ("");
10318 }
10319 }
10320 break;
10321
10322 case DT_PLTREL:
10323 dynamic_info[entry->d_tag] = entry->d_un.d_val;
10324 if (do_dynamic)
10325 puts (get_dynamic_type (filedata, entry->d_un.d_val));
10326 break;
10327
10328 case DT_NULL :
10329 case DT_NEEDED :
10330 case DT_PLTGOT :
10331 case DT_HASH :
10332 case DT_STRTAB :
10333 case DT_SYMTAB :
10334 case DT_RELA :
10335 case DT_INIT :
10336 case DT_FINI :
10337 case DT_SONAME :
10338 case DT_RPATH :
10339 case DT_SYMBOLIC:
10340 case DT_REL :
10341 case DT_DEBUG :
10342 case DT_TEXTREL :
10343 case DT_JMPREL :
10344 case DT_RUNPATH :
10345 dynamic_info[entry->d_tag] = entry->d_un.d_val;
10346
10347 if (do_dynamic)
10348 {
10349 char * name;
10350
10351 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
10352 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10353 else
10354 name = NULL;
10355
10356 if (name)
10357 {
10358 switch (entry->d_tag)
10359 {
10360 case DT_NEEDED:
10361 printf (_("Shared library: [%s]"), name);
10362
10363 if (streq (name, program_interpreter))
10364 printf (_(" program interpreter"));
10365 break;
10366
10367 case DT_SONAME:
10368 printf (_("Library soname: [%s]"), name);
10369 break;
10370
10371 case DT_RPATH:
10372 printf (_("Library rpath: [%s]"), name);
10373 break;
10374
10375 case DT_RUNPATH:
10376 printf (_("Library runpath: [%s]"), name);
10377 break;
10378
10379 default:
10380 print_vma (entry->d_un.d_val, PREFIX_HEX);
10381 break;
10382 }
10383 }
10384 else
10385 print_vma (entry->d_un.d_val, PREFIX_HEX);
10386
10387 putchar ('\n');
10388 }
10389 break;
10390
10391 case DT_PLTRELSZ:
10392 case DT_RELASZ :
10393 case DT_STRSZ :
10394 case DT_RELSZ :
10395 case DT_RELAENT :
10396 case DT_SYMENT :
10397 case DT_RELENT :
10398 dynamic_info[entry->d_tag] = entry->d_un.d_val;
10399 /* Fall through. */
10400 case DT_PLTPADSZ:
10401 case DT_MOVEENT :
10402 case DT_MOVESZ :
10403 case DT_INIT_ARRAYSZ:
10404 case DT_FINI_ARRAYSZ:
10405 case DT_GNU_CONFLICTSZ:
10406 case DT_GNU_LIBLISTSZ:
10407 if (do_dynamic)
10408 {
10409 print_vma (entry->d_un.d_val, UNSIGNED);
10410 printf (_(" (bytes)\n"));
10411 }
10412 break;
10413
10414 case DT_VERDEFNUM:
10415 case DT_VERNEEDNUM:
10416 case DT_RELACOUNT:
10417 case DT_RELCOUNT:
10418 if (do_dynamic)
10419 {
10420 print_vma (entry->d_un.d_val, UNSIGNED);
10421 putchar ('\n');
10422 }
10423 break;
10424
10425 case DT_SYMINSZ:
10426 case DT_SYMINENT:
10427 case DT_SYMINFO:
10428 case DT_USED:
10429 case DT_INIT_ARRAY:
10430 case DT_FINI_ARRAY:
10431 if (do_dynamic)
10432 {
10433 if (entry->d_tag == DT_USED
10434 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
10435 {
10436 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10437
10438 if (*name)
10439 {
10440 printf (_("Not needed object: [%s]\n"), name);
10441 break;
10442 }
10443 }
10444
10445 print_vma (entry->d_un.d_val, PREFIX_HEX);
10446 putchar ('\n');
10447 }
10448 break;
10449
10450 case DT_BIND_NOW:
10451 /* The value of this entry is ignored. */
10452 if (do_dynamic)
10453 putchar ('\n');
10454 break;
10455
10456 case DT_GNU_PRELINKED:
10457 if (do_dynamic)
10458 {
10459 struct tm * tmp;
10460 time_t atime = entry->d_un.d_val;
10461
10462 tmp = gmtime (&atime);
10463 /* PR 17533 file: 041-1244816-0.004. */
10464 if (tmp == NULL)
10465 printf (_("<corrupt time val: %lx"),
10466 (unsigned long) atime);
10467 else
10468 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10469 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10470 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10471
10472 }
10473 break;
10474
10475 case DT_GNU_HASH:
10476 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10477 if (do_dynamic)
10478 {
10479 print_vma (entry->d_un.d_val, PREFIX_HEX);
10480 putchar ('\n');
10481 }
10482 break;
10483
10484 default:
10485 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
10486 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
10487 entry->d_un.d_val;
10488
10489 if (do_dynamic)
10490 {
10491 switch (filedata->file_header.e_machine)
10492 {
10493 case EM_AARCH64:
10494 dynamic_section_aarch64_val (entry);
10495 break;
10496 case EM_MIPS:
10497 case EM_MIPS_RS3_LE:
10498 dynamic_section_mips_val (entry);
10499 break;
10500 case EM_PARISC:
10501 dynamic_section_parisc_val (entry);
10502 break;
10503 case EM_IA_64:
10504 dynamic_section_ia64_val (entry);
10505 break;
10506 default:
10507 print_vma (entry->d_un.d_val, PREFIX_HEX);
10508 putchar ('\n');
10509 }
10510 }
10511 break;
10512 }
10513 }
10514
10515 return TRUE;
10516 }
10517
10518 static char *
get_ver_flags(unsigned int flags)10519 get_ver_flags (unsigned int flags)
10520 {
10521 static char buff[128];
10522
10523 buff[0] = 0;
10524
10525 if (flags == 0)
10526 return _("none");
10527
10528 if (flags & VER_FLG_BASE)
10529 strcat (buff, "BASE");
10530
10531 if (flags & VER_FLG_WEAK)
10532 {
10533 if (flags & VER_FLG_BASE)
10534 strcat (buff, " | ");
10535
10536 strcat (buff, "WEAK");
10537 }
10538
10539 if (flags & VER_FLG_INFO)
10540 {
10541 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10542 strcat (buff, " | ");
10543
10544 strcat (buff, "INFO");
10545 }
10546
10547 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10548 {
10549 if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10550 strcat (buff, " | ");
10551
10552 strcat (buff, _("<unknown>"));
10553 }
10554
10555 return buff;
10556 }
10557
10558 /* Display the contents of the version sections. */
10559
10560 static bfd_boolean
process_version_sections(Filedata * filedata)10561 process_version_sections (Filedata * filedata)
10562 {
10563 Elf_Internal_Shdr * section;
10564 unsigned i;
10565 bfd_boolean found = FALSE;
10566
10567 if (! do_version)
10568 return TRUE;
10569
10570 for (i = 0, section = filedata->section_headers;
10571 i < filedata->file_header.e_shnum;
10572 i++, section++)
10573 {
10574 switch (section->sh_type)
10575 {
10576 case SHT_GNU_verdef:
10577 {
10578 Elf_External_Verdef * edefs;
10579 unsigned long idx;
10580 unsigned long cnt;
10581 char * endbuf;
10582
10583 found = TRUE;
10584
10585 printf (ngettext ("\nVersion definition section '%s' "
10586 "contains %u entry:\n",
10587 "\nVersion definition section '%s' "
10588 "contains %u entries:\n",
10589 section->sh_info),
10590 printable_section_name (filedata, section),
10591 section->sh_info);
10592
10593 printf (_(" Addr: 0x"));
10594 printf_vma (section->sh_addr);
10595 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10596 (unsigned long) section->sh_offset, section->sh_link,
10597 printable_section_name_from_index (filedata, section->sh_link));
10598
10599 edefs = (Elf_External_Verdef *)
10600 get_data (NULL, filedata, section->sh_offset, 1,section->sh_size,
10601 _("version definition section"));
10602 if (!edefs)
10603 break;
10604 endbuf = (char *) edefs + section->sh_size;
10605
10606 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10607 {
10608 char * vstart;
10609 Elf_External_Verdef * edef;
10610 Elf_Internal_Verdef ent;
10611 Elf_External_Verdaux * eaux;
10612 Elf_Internal_Verdaux aux;
10613 unsigned long isum;
10614 int j;
10615
10616 vstart = ((char *) edefs) + idx;
10617 if (vstart + sizeof (*edef) > endbuf)
10618 break;
10619
10620 edef = (Elf_External_Verdef *) vstart;
10621
10622 ent.vd_version = BYTE_GET (edef->vd_version);
10623 ent.vd_flags = BYTE_GET (edef->vd_flags);
10624 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
10625 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
10626 ent.vd_hash = BYTE_GET (edef->vd_hash);
10627 ent.vd_aux = BYTE_GET (edef->vd_aux);
10628 ent.vd_next = BYTE_GET (edef->vd_next);
10629
10630 printf (_(" %#06lx: Rev: %d Flags: %s"),
10631 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10632
10633 printf (_(" Index: %d Cnt: %d "),
10634 ent.vd_ndx, ent.vd_cnt);
10635
10636 /* Check for overflow. */
10637 if (ent.vd_aux > (size_t) (endbuf - vstart))
10638 break;
10639
10640 vstart += ent.vd_aux;
10641
10642 if (vstart + sizeof (*eaux) > endbuf)
10643 break;
10644 eaux = (Elf_External_Verdaux *) vstart;
10645
10646 aux.vda_name = BYTE_GET (eaux->vda_name);
10647 aux.vda_next = BYTE_GET (eaux->vda_next);
10648
10649 if (VALID_DYNAMIC_NAME (aux.vda_name))
10650 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
10651 else
10652 printf (_("Name index: %ld\n"), aux.vda_name);
10653
10654 isum = idx + ent.vd_aux;
10655
10656 for (j = 1; j < ent.vd_cnt; j++)
10657 {
10658 if (aux.vda_next < sizeof (*eaux)
10659 && !(j == ent.vd_cnt - 1 && aux.vda_next == 0))
10660 {
10661 warn (_("Invalid vda_next field of %lx\n"),
10662 aux.vda_next);
10663 j = ent.vd_cnt;
10664 break;
10665 }
10666 /* Check for overflow. */
10667 if (aux.vda_next > (size_t) (endbuf - vstart))
10668 break;
10669
10670 isum += aux.vda_next;
10671 vstart += aux.vda_next;
10672
10673 if (vstart + sizeof (*eaux) > endbuf)
10674 break;
10675 eaux = (Elf_External_Verdaux *) vstart;
10676
10677 aux.vda_name = BYTE_GET (eaux->vda_name);
10678 aux.vda_next = BYTE_GET (eaux->vda_next);
10679
10680 if (VALID_DYNAMIC_NAME (aux.vda_name))
10681 printf (_(" %#06lx: Parent %d: %s\n"),
10682 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
10683 else
10684 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10685 isum, j, aux.vda_name);
10686 }
10687
10688 if (j < ent.vd_cnt)
10689 printf (_(" Version def aux past end of section\n"));
10690
10691 /* PR 17531:
10692 file: id:000001,src:000172+005151,op:splice,rep:2. */
10693 if (ent.vd_next < sizeof (*edef)
10694 && !(cnt == section->sh_info - 1 && ent.vd_next == 0))
10695 {
10696 warn (_("Invalid vd_next field of %lx\n"), ent.vd_next);
10697 cnt = section->sh_info;
10698 break;
10699 }
10700 if (ent.vd_next > (size_t) (endbuf - ((char *) edefs + idx)))
10701 break;
10702
10703 idx += ent.vd_next;
10704 }
10705
10706 if (cnt < section->sh_info)
10707 printf (_(" Version definition past end of section\n"));
10708
10709 free (edefs);
10710 }
10711 break;
10712
10713 case SHT_GNU_verneed:
10714 {
10715 Elf_External_Verneed * eneed;
10716 unsigned long idx;
10717 unsigned long cnt;
10718 char * endbuf;
10719
10720 found = TRUE;
10721
10722 printf (ngettext ("\nVersion needs section '%s' "
10723 "contains %u entry:\n",
10724 "\nVersion needs section '%s' "
10725 "contains %u entries:\n",
10726 section->sh_info),
10727 printable_section_name (filedata, section), section->sh_info);
10728
10729 printf (_(" Addr: 0x"));
10730 printf_vma (section->sh_addr);
10731 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10732 (unsigned long) section->sh_offset, section->sh_link,
10733 printable_section_name_from_index (filedata, section->sh_link));
10734
10735 eneed = (Elf_External_Verneed *) get_data (NULL, filedata,
10736 section->sh_offset, 1,
10737 section->sh_size,
10738 _("Version Needs section"));
10739 if (!eneed)
10740 break;
10741 endbuf = (char *) eneed + section->sh_size;
10742
10743 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10744 {
10745 Elf_External_Verneed * entry;
10746 Elf_Internal_Verneed ent;
10747 unsigned long isum;
10748 int j;
10749 char * vstart;
10750
10751 vstart = ((char *) eneed) + idx;
10752 if (vstart + sizeof (*entry) > endbuf)
10753 break;
10754
10755 entry = (Elf_External_Verneed *) vstart;
10756
10757 ent.vn_version = BYTE_GET (entry->vn_version);
10758 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
10759 ent.vn_file = BYTE_GET (entry->vn_file);
10760 ent.vn_aux = BYTE_GET (entry->vn_aux);
10761 ent.vn_next = BYTE_GET (entry->vn_next);
10762
10763 printf (_(" %#06lx: Version: %d"), idx, ent.vn_version);
10764
10765 if (VALID_DYNAMIC_NAME (ent.vn_file))
10766 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
10767 else
10768 printf (_(" File: %lx"), ent.vn_file);
10769
10770 printf (_(" Cnt: %d\n"), ent.vn_cnt);
10771
10772 /* Check for overflow. */
10773 if (ent.vn_aux > (size_t) (endbuf - vstart))
10774 break;
10775 vstart += ent.vn_aux;
10776
10777 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10778 {
10779 Elf_External_Vernaux * eaux;
10780 Elf_Internal_Vernaux aux;
10781
10782 if (vstart + sizeof (*eaux) > endbuf)
10783 break;
10784 eaux = (Elf_External_Vernaux *) vstart;
10785
10786 aux.vna_hash = BYTE_GET (eaux->vna_hash);
10787 aux.vna_flags = BYTE_GET (eaux->vna_flags);
10788 aux.vna_other = BYTE_GET (eaux->vna_other);
10789 aux.vna_name = BYTE_GET (eaux->vna_name);
10790 aux.vna_next = BYTE_GET (eaux->vna_next);
10791
10792 if (VALID_DYNAMIC_NAME (aux.vna_name))
10793 printf (_(" %#06lx: Name: %s"),
10794 isum, GET_DYNAMIC_NAME (aux.vna_name));
10795 else
10796 printf (_(" %#06lx: Name index: %lx"),
10797 isum, aux.vna_name);
10798
10799 printf (_(" Flags: %s Version: %d\n"),
10800 get_ver_flags (aux.vna_flags), aux.vna_other);
10801
10802 if (aux.vna_next < sizeof (*eaux)
10803 && !(j == ent.vn_cnt - 1 && aux.vna_next == 0))
10804 {
10805 warn (_("Invalid vna_next field of %lx\n"),
10806 aux.vna_next);
10807 j = ent.vn_cnt;
10808 break;
10809 }
10810 /* Check for overflow. */
10811 if (aux.vna_next > (size_t) (endbuf - vstart))
10812 break;
10813 isum += aux.vna_next;
10814 vstart += aux.vna_next;
10815 }
10816
10817 if (j < ent.vn_cnt)
10818 warn (_("Missing Version Needs auxillary information\n"));
10819
10820 if (ent.vn_next < sizeof (*entry)
10821 && !(cnt == section->sh_info - 1 && ent.vn_next == 0))
10822 {
10823 warn (_("Invalid vn_next field of %lx\n"), ent.vn_next);
10824 cnt = section->sh_info;
10825 break;
10826 }
10827 if (ent.vn_next > (size_t) (endbuf - ((char *) eneed + idx)))
10828 break;
10829 idx += ent.vn_next;
10830 }
10831
10832 if (cnt < section->sh_info)
10833 warn (_("Missing Version Needs information\n"));
10834
10835 free (eneed);
10836 }
10837 break;
10838
10839 case SHT_GNU_versym:
10840 {
10841 Elf_Internal_Shdr * link_section;
10842 size_t total;
10843 unsigned int cnt;
10844 unsigned char * edata;
10845 unsigned short * data;
10846 char * strtab;
10847 Elf_Internal_Sym * symbols;
10848 Elf_Internal_Shdr * string_sec;
10849 unsigned long num_syms;
10850 long off;
10851
10852 if (section->sh_link >= filedata->file_header.e_shnum)
10853 break;
10854
10855 link_section = filedata->section_headers + section->sh_link;
10856 total = section->sh_size / sizeof (Elf_External_Versym);
10857
10858 if (link_section->sh_link >= filedata->file_header.e_shnum)
10859 break;
10860
10861 found = TRUE;
10862
10863 symbols = GET_ELF_SYMBOLS (filedata, link_section, & num_syms);
10864 if (symbols == NULL)
10865 break;
10866
10867 string_sec = filedata->section_headers + link_section->sh_link;
10868
10869 strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
10870 string_sec->sh_size,
10871 _("version string table"));
10872 if (!strtab)
10873 {
10874 free (symbols);
10875 break;
10876 }
10877
10878 printf (ngettext ("\nVersion symbols section '%s' "
10879 "contains %lu entry:\n",
10880 "\nVersion symbols section '%s' "
10881 "contains %lu entries:\n",
10882 total),
10883 printable_section_name (filedata, section), (unsigned long) total);
10884
10885 printf (_(" Addr: 0x"));
10886 printf_vma (section->sh_addr);
10887 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10888 (unsigned long) section->sh_offset, section->sh_link,
10889 printable_section_name (filedata, link_section));
10890
10891 off = offset_from_vma (filedata,
10892 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10893 total * sizeof (short));
10894 edata = (unsigned char *) get_data (NULL, filedata, off, total,
10895 sizeof (short),
10896 _("version symbol data"));
10897 if (!edata)
10898 {
10899 free (strtab);
10900 free (symbols);
10901 break;
10902 }
10903
10904 data = (short unsigned int *) cmalloc (total, sizeof (short));
10905
10906 for (cnt = total; cnt --;)
10907 data[cnt] = byte_get (edata + cnt * sizeof (short),
10908 sizeof (short));
10909
10910 free (edata);
10911
10912 for (cnt = 0; cnt < total; cnt += 4)
10913 {
10914 int j, nn;
10915 char *name;
10916 char *invalid = _("*invalid*");
10917
10918 printf (" %03x:", cnt);
10919
10920 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10921 switch (data[cnt + j])
10922 {
10923 case 0:
10924 fputs (_(" 0 (*local*) "), stdout);
10925 break;
10926
10927 case 1:
10928 fputs (_(" 1 (*global*) "), stdout);
10929 break;
10930
10931 default:
10932 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10933 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10934
10935 /* If this index value is greater than the size of the symbols
10936 array, break to avoid an out-of-bounds read. */
10937 if ((unsigned long)(cnt + j) >= num_syms)
10938 {
10939 warn (_("invalid index into symbol array\n"));
10940 break;
10941 }
10942
10943 name = NULL;
10944 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10945 {
10946 Elf_Internal_Verneed ivn;
10947 unsigned long offset;
10948
10949 offset = offset_from_vma
10950 (filedata, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10951 sizeof (Elf_External_Verneed));
10952
10953 do
10954 {
10955 Elf_Internal_Vernaux ivna;
10956 Elf_External_Verneed evn;
10957 Elf_External_Vernaux evna;
10958 unsigned long a_off;
10959
10960 if (get_data (&evn, filedata, offset, sizeof (evn), 1,
10961 _("version need")) == NULL)
10962 break;
10963
10964 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10965 ivn.vn_next = BYTE_GET (evn.vn_next);
10966
10967 a_off = offset + ivn.vn_aux;
10968
10969 do
10970 {
10971 if (get_data (&evna, filedata, a_off, sizeof (evna),
10972 1, _("version need aux (2)")) == NULL)
10973 {
10974 ivna.vna_next = 0;
10975 ivna.vna_other = 0;
10976 }
10977 else
10978 {
10979 ivna.vna_next = BYTE_GET (evna.vna_next);
10980 ivna.vna_other = BYTE_GET (evna.vna_other);
10981 }
10982
10983 a_off += ivna.vna_next;
10984 }
10985 while (ivna.vna_other != data[cnt + j]
10986 && ivna.vna_next != 0);
10987
10988 if (ivna.vna_other == data[cnt + j])
10989 {
10990 ivna.vna_name = BYTE_GET (evna.vna_name);
10991
10992 if (ivna.vna_name >= string_sec->sh_size)
10993 name = invalid;
10994 else
10995 name = strtab + ivna.vna_name;
10996 break;
10997 }
10998
10999 offset += ivn.vn_next;
11000 }
11001 while (ivn.vn_next);
11002 }
11003
11004 if (data[cnt + j] != 0x8001
11005 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11006 {
11007 Elf_Internal_Verdef ivd;
11008 Elf_External_Verdef evd;
11009 unsigned long offset;
11010
11011 offset = offset_from_vma
11012 (filedata, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11013 sizeof evd);
11014
11015 do
11016 {
11017 if (get_data (&evd, filedata, offset, sizeof (evd), 1,
11018 _("version def")) == NULL)
11019 {
11020 ivd.vd_next = 0;
11021 /* PR 17531: file: 046-1082287-0.004. */
11022 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
11023 break;
11024 }
11025 else
11026 {
11027 ivd.vd_next = BYTE_GET (evd.vd_next);
11028 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11029 }
11030
11031 offset += ivd.vd_next;
11032 }
11033 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
11034 && ivd.vd_next != 0);
11035
11036 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
11037 {
11038 Elf_External_Verdaux evda;
11039 Elf_Internal_Verdaux ivda;
11040
11041 ivd.vd_aux = BYTE_GET (evd.vd_aux);
11042
11043 if (get_data (&evda, filedata,
11044 offset - ivd.vd_next + ivd.vd_aux,
11045 sizeof (evda), 1,
11046 _("version def aux")) == NULL)
11047 break;
11048
11049 ivda.vda_name = BYTE_GET (evda.vda_name);
11050
11051 if (ivda.vda_name >= string_sec->sh_size)
11052 name = invalid;
11053 else if (name != NULL && name != invalid)
11054 name = _("*both*");
11055 else
11056 name = strtab + ivda.vda_name;
11057 }
11058 }
11059 if (name != NULL)
11060 nn += printf ("(%s%-*s",
11061 name,
11062 12 - (int) strlen (name),
11063 ")");
11064
11065 if (nn < 18)
11066 printf ("%*c", 18 - nn, ' ');
11067 }
11068
11069 putchar ('\n');
11070 }
11071
11072 free (data);
11073 free (strtab);
11074 free (symbols);
11075 }
11076 break;
11077
11078 default:
11079 break;
11080 }
11081 }
11082
11083 if (! found)
11084 printf (_("\nNo version information found in this file.\n"));
11085
11086 return TRUE;
11087 }
11088
11089 static const char *
get_symbol_binding(Filedata * filedata,unsigned int binding)11090 get_symbol_binding (Filedata * filedata, unsigned int binding)
11091 {
11092 static char buff[32];
11093
11094 switch (binding)
11095 {
11096 case STB_LOCAL: return "LOCAL";
11097 case STB_GLOBAL: return "GLOBAL";
11098 case STB_WEAK: return "WEAK";
11099 default:
11100 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
11101 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
11102 binding);
11103 else if (binding >= STB_LOOS && binding <= STB_HIOS)
11104 {
11105 if (binding == STB_GNU_UNIQUE
11106 && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU)
11107 return "UNIQUE";
11108 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
11109 }
11110 else
11111 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
11112 return buff;
11113 }
11114 }
11115
11116 static const char *
get_symbol_type(Filedata * filedata,unsigned int type)11117 get_symbol_type (Filedata * filedata, unsigned int type)
11118 {
11119 static char buff[32];
11120
11121 switch (type)
11122 {
11123 case STT_NOTYPE: return "NOTYPE";
11124 case STT_OBJECT: return "OBJECT";
11125 case STT_FUNC: return "FUNC";
11126 case STT_SECTION: return "SECTION";
11127 case STT_FILE: return "FILE";
11128 case STT_COMMON: return "COMMON";
11129 case STT_TLS: return "TLS";
11130 case STT_RELC: return "RELC";
11131 case STT_SRELC: return "SRELC";
11132 default:
11133 if (type >= STT_LOPROC && type <= STT_HIPROC)
11134 {
11135 if (filedata->file_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
11136 return "THUMB_FUNC";
11137
11138 if (filedata->file_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
11139 return "REGISTER";
11140
11141 if (filedata->file_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
11142 return "PARISC_MILLI";
11143
11144 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
11145 }
11146 else if (type >= STT_LOOS && type <= STT_HIOS)
11147 {
11148 if (filedata->file_header.e_machine == EM_PARISC)
11149 {
11150 if (type == STT_HP_OPAQUE)
11151 return "HP_OPAQUE";
11152 if (type == STT_HP_STUB)
11153 return "HP_STUB";
11154 }
11155
11156 if (type == STT_GNU_IFUNC
11157 && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
11158 || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD))
11159 return "IFUNC";
11160
11161 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
11162 }
11163 else
11164 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
11165 return buff;
11166 }
11167 }
11168
11169 static const char *
get_symbol_visibility(unsigned int visibility)11170 get_symbol_visibility (unsigned int visibility)
11171 {
11172 switch (visibility)
11173 {
11174 case STV_DEFAULT: return "DEFAULT";
11175 case STV_INTERNAL: return "INTERNAL";
11176 case STV_HIDDEN: return "HIDDEN";
11177 case STV_PROTECTED: return "PROTECTED";
11178 default:
11179 error (_("Unrecognized visibility value: %u"), visibility);
11180 return _("<unknown>");
11181 }
11182 }
11183
11184 static const char *
get_alpha_symbol_other(unsigned int other)11185 get_alpha_symbol_other (unsigned int other)
11186 {
11187 switch (other)
11188 {
11189 case STO_ALPHA_NOPV: return "NOPV";
11190 case STO_ALPHA_STD_GPLOAD: return "STD GPLOAD";
11191 default:
11192 error (_("Unrecognized alpah specific other value: %u"), other);
11193 return _("<unknown>");
11194 }
11195 }
11196
11197 static const char *
get_solaris_symbol_visibility(unsigned int visibility)11198 get_solaris_symbol_visibility (unsigned int visibility)
11199 {
11200 switch (visibility)
11201 {
11202 case 4: return "EXPORTED";
11203 case 5: return "SINGLETON";
11204 case 6: return "ELIMINATE";
11205 default: return get_symbol_visibility (visibility);
11206 }
11207 }
11208
11209 static const char *
get_aarch64_symbol_other(unsigned int other)11210 get_aarch64_symbol_other (unsigned int other)
11211 {
11212 static char buf[32];
11213
11214 if (other & STO_AARCH64_VARIANT_PCS)
11215 {
11216 other &= ~STO_AARCH64_VARIANT_PCS;
11217 if (other == 0)
11218 return "VARIANT_PCS";
11219 snprintf (buf, sizeof buf, "VARIANT_PCS | %x", other);
11220 return buf;
11221 }
11222 return NULL;
11223 }
11224
11225 static const char *
get_mips_symbol_other(unsigned int other)11226 get_mips_symbol_other (unsigned int other)
11227 {
11228 switch (other)
11229 {
11230 case STO_OPTIONAL: return "OPTIONAL";
11231 case STO_MIPS_PLT: return "MIPS PLT";
11232 case STO_MIPS_PIC: return "MIPS PIC";
11233 case STO_MICROMIPS: return "MICROMIPS";
11234 case STO_MICROMIPS | STO_MIPS_PIC: return "MICROMIPS, MIPS PIC";
11235 case STO_MIPS16: return "MIPS16";
11236 default: return NULL;
11237 }
11238 }
11239
11240 static const char *
get_ia64_symbol_other(Filedata * filedata,unsigned int other)11241 get_ia64_symbol_other (Filedata * filedata, unsigned int other)
11242 {
11243 if (is_ia64_vms (filedata))
11244 {
11245 static char res[32];
11246
11247 res[0] = 0;
11248
11249 /* Function types is for images and .STB files only. */
11250 switch (filedata->file_header.e_type)
11251 {
11252 case ET_DYN:
11253 case ET_EXEC:
11254 switch (VMS_ST_FUNC_TYPE (other))
11255 {
11256 case VMS_SFT_CODE_ADDR:
11257 strcat (res, " CA");
11258 break;
11259 case VMS_SFT_SYMV_IDX:
11260 strcat (res, " VEC");
11261 break;
11262 case VMS_SFT_FD:
11263 strcat (res, " FD");
11264 break;
11265 case VMS_SFT_RESERVE:
11266 strcat (res, " RSV");
11267 break;
11268 default:
11269 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11270 VMS_ST_FUNC_TYPE (other));
11271 strcat (res, " <unknown>");
11272 break;
11273 }
11274 break;
11275 default:
11276 break;
11277 }
11278 switch (VMS_ST_LINKAGE (other))
11279 {
11280 case VMS_STL_IGNORE:
11281 strcat (res, " IGN");
11282 break;
11283 case VMS_STL_RESERVE:
11284 strcat (res, " RSV");
11285 break;
11286 case VMS_STL_STD:
11287 strcat (res, " STD");
11288 break;
11289 case VMS_STL_LNK:
11290 strcat (res, " LNK");
11291 break;
11292 default:
11293 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11294 VMS_ST_LINKAGE (other));
11295 strcat (res, " <unknown>");
11296 break;
11297 }
11298
11299 if (res[0] != 0)
11300 return res + 1;
11301 else
11302 return res;
11303 }
11304 return NULL;
11305 }
11306
11307 static const char *
get_ppc64_symbol_other(unsigned int other)11308 get_ppc64_symbol_other (unsigned int other)
11309 {
11310 if ((other & ~STO_PPC64_LOCAL_MASK) != 0)
11311 return NULL;
11312
11313 other >>= STO_PPC64_LOCAL_BIT;
11314 if (other <= 6)
11315 {
11316 static char buf[32];
11317 if (other >= 2)
11318 other = ppc64_decode_local_entry (other);
11319 snprintf (buf, sizeof buf, _("<localentry>: %d"), other);
11320 return buf;
11321 }
11322 return NULL;
11323 }
11324
11325 static const char *
get_symbol_other(Filedata * filedata,unsigned int other)11326 get_symbol_other (Filedata * filedata, unsigned int other)
11327 {
11328 const char * result = NULL;
11329 static char buff [32];
11330
11331 if (other == 0)
11332 return "";
11333
11334 switch (filedata->file_header.e_machine)
11335 {
11336 case EM_ALPHA:
11337 result = get_alpha_symbol_other (other);
11338 break;
11339 case EM_AARCH64:
11340 result = get_aarch64_symbol_other (other);
11341 break;
11342 case EM_MIPS:
11343 result = get_mips_symbol_other (other);
11344 break;
11345 case EM_IA_64:
11346 result = get_ia64_symbol_other (filedata, other);
11347 break;
11348 case EM_PPC64:
11349 result = get_ppc64_symbol_other (other);
11350 break;
11351 default:
11352 result = NULL;
11353 break;
11354 }
11355
11356 if (result)
11357 return result;
11358
11359 snprintf (buff, sizeof buff, _("<other>: %x"), other);
11360 return buff;
11361 }
11362
11363 static const char *
get_symbol_index_type(Filedata * filedata,unsigned int type)11364 get_symbol_index_type (Filedata * filedata, unsigned int type)
11365 {
11366 static char buff[32];
11367
11368 switch (type)
11369 {
11370 case SHN_UNDEF: return "UND";
11371 case SHN_ABS: return "ABS";
11372 case SHN_COMMON: return "COM";
11373 default:
11374 if (type == SHN_IA_64_ANSI_COMMON
11375 && filedata->file_header.e_machine == EM_IA_64
11376 && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
11377 return "ANSI_COM";
11378 else if ((filedata->file_header.e_machine == EM_X86_64
11379 || filedata->file_header.e_machine == EM_L1OM
11380 || filedata->file_header.e_machine == EM_K1OM)
11381 && type == SHN_X86_64_LCOMMON)
11382 return "LARGE_COM";
11383 else if ((type == SHN_MIPS_SCOMMON
11384 && filedata->file_header.e_machine == EM_MIPS)
11385 || (type == SHN_TIC6X_SCOMMON
11386 && filedata->file_header.e_machine == EM_TI_C6000))
11387 return "SCOM";
11388 else if (type == SHN_MIPS_SUNDEFINED
11389 && filedata->file_header.e_machine == EM_MIPS)
11390 return "SUND";
11391 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
11392 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
11393 else if (type >= SHN_LOOS && type <= SHN_HIOS)
11394 sprintf (buff, "OS [0x%04x]", type & 0xffff);
11395 else if (type >= SHN_LORESERVE)
11396 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
11397 else if (type >= filedata->file_header.e_shnum)
11398 sprintf (buff, _("bad section index[%3d]"), type);
11399 else
11400 sprintf (buff, "%3d", type);
11401 break;
11402 }
11403
11404 return buff;
11405 }
11406
11407 static bfd_vma *
get_dynamic_data(Filedata * filedata,bfd_size_type number,unsigned int ent_size)11408 get_dynamic_data (Filedata * filedata, bfd_size_type number, unsigned int ent_size)
11409 {
11410 unsigned char * e_data;
11411 bfd_vma * i_data;
11412
11413 /* If the size_t type is smaller than the bfd_size_type, eg because
11414 you are building a 32-bit tool on a 64-bit host, then make sure
11415 that when (number) is cast to (size_t) no information is lost. */
11416 if (sizeof (size_t) < sizeof (bfd_size_type)
11417 && (bfd_size_type) ((size_t) number) != number)
11418 {
11419 error (_("Size truncation prevents reading %s elements of size %u\n"),
11420 bfd_vmatoa ("u", number), ent_size);
11421 return NULL;
11422 }
11423
11424 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11425 attempting to allocate memory when the read is bound to fail. */
11426 if (ent_size * number > filedata->file_size)
11427 {
11428 error (_("Invalid number of dynamic entries: %s\n"),
11429 bfd_vmatoa ("u", number));
11430 return NULL;
11431 }
11432
11433 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
11434 if (e_data == NULL)
11435 {
11436 error (_("Out of memory reading %s dynamic entries\n"),
11437 bfd_vmatoa ("u", number));
11438 return NULL;
11439 }
11440
11441 if (fread (e_data, ent_size, (size_t) number, filedata->handle) != number)
11442 {
11443 error (_("Unable to read in %s bytes of dynamic data\n"),
11444 bfd_vmatoa ("u", number * ent_size));
11445 free (e_data);
11446 return NULL;
11447 }
11448
11449 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
11450 if (i_data == NULL)
11451 {
11452 error (_("Out of memory allocating space for %s dynamic entries\n"),
11453 bfd_vmatoa ("u", number));
11454 free (e_data);
11455 return NULL;
11456 }
11457
11458 while (number--)
11459 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
11460
11461 free (e_data);
11462
11463 return i_data;
11464 }
11465
11466 static void
print_dynamic_symbol(Filedata * filedata,bfd_vma si,unsigned long hn)11467 print_dynamic_symbol (Filedata * filedata, bfd_vma si, unsigned long hn)
11468 {
11469 Elf_Internal_Sym * psym;
11470 int n;
11471
11472 n = print_vma (si, DEC_5);
11473 if (n < 5)
11474 fputs (&" "[n], stdout);
11475 printf (" %3lu: ", hn);
11476
11477 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
11478 {
11479 printf (_("<No info available for dynamic symbol number %lu>\n"),
11480 (unsigned long) si);
11481 return;
11482 }
11483
11484 psym = dynamic_symbols + si;
11485 print_vma (psym->st_value, LONG_HEX);
11486 putchar (' ');
11487 print_vma (psym->st_size, DEC_5);
11488
11489 printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11490 printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11491
11492 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11493 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
11494 else
11495 {
11496 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11497
11498 printf (" %-7s", get_symbol_visibility (vis));
11499 /* Check to see if any other bits in the st_other field are set.
11500 Note - displaying this information disrupts the layout of the
11501 table being generated, but for the moment this case is very
11502 rare. */
11503 if (psym->st_other ^ vis)
11504 printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11505 }
11506
11507 printf (" %3.3s ", get_symbol_index_type (filedata, psym->st_shndx));
11508 if (VALID_DYNAMIC_NAME (psym->st_name))
11509 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11510 else
11511 printf (_(" <corrupt: %14ld>"), psym->st_name);
11512 putchar ('\n');
11513 }
11514
11515 static const char *
get_symbol_version_string(Filedata * filedata,bfd_boolean is_dynsym,const char * strtab,unsigned long int strtab_size,unsigned int si,Elf_Internal_Sym * psym,enum versioned_symbol_info * sym_info,unsigned short * vna_other)11516 get_symbol_version_string (Filedata * filedata,
11517 bfd_boolean is_dynsym,
11518 const char * strtab,
11519 unsigned long int strtab_size,
11520 unsigned int si,
11521 Elf_Internal_Sym * psym,
11522 enum versioned_symbol_info * sym_info,
11523 unsigned short * vna_other)
11524 {
11525 unsigned char data[2];
11526 unsigned short vers_data;
11527 unsigned long offset;
11528 unsigned short max_vd_ndx;
11529
11530 if (!is_dynsym
11531 || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11532 return NULL;
11533
11534 offset = offset_from_vma (filedata, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11535 sizeof data + si * sizeof (vers_data));
11536
11537 if (get_data (&data, filedata, offset + si * sizeof (vers_data),
11538 sizeof (data), 1, _("version data")) == NULL)
11539 return NULL;
11540
11541 vers_data = byte_get (data, 2);
11542
11543 if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data == 0)
11544 return NULL;
11545
11546 *sym_info = (vers_data & VERSYM_HIDDEN) != 0 ? symbol_hidden : symbol_public;
11547 max_vd_ndx = 0;
11548
11549 /* Usually we'd only see verdef for defined symbols, and verneed for
11550 undefined symbols. However, symbols defined by the linker in
11551 .dynbss for variables copied from a shared library in order to
11552 avoid text relocations are defined yet have verneed. We could
11553 use a heuristic to detect the special case, for example, check
11554 for verneed first on symbols defined in SHT_NOBITS sections, but
11555 it is simpler and more reliable to just look for both verdef and
11556 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11557
11558 if (psym->st_shndx != SHN_UNDEF
11559 && vers_data != 0x8001
11560 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11561 {
11562 Elf_Internal_Verdef ivd;
11563 Elf_Internal_Verdaux ivda;
11564 Elf_External_Verdaux evda;
11565 unsigned long off;
11566
11567 off = offset_from_vma (filedata,
11568 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11569 sizeof (Elf_External_Verdef));
11570
11571 do
11572 {
11573 Elf_External_Verdef evd;
11574
11575 if (get_data (&evd, filedata, off, sizeof (evd), 1,
11576 _("version def")) == NULL)
11577 {
11578 ivd.vd_ndx = 0;
11579 ivd.vd_aux = 0;
11580 ivd.vd_next = 0;
11581 ivd.vd_flags = 0;
11582 }
11583 else
11584 {
11585 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11586 ivd.vd_aux = BYTE_GET (evd.vd_aux);
11587 ivd.vd_next = BYTE_GET (evd.vd_next);
11588 ivd.vd_flags = BYTE_GET (evd.vd_flags);
11589 }
11590
11591 if ((ivd.vd_ndx & VERSYM_VERSION) > max_vd_ndx)
11592 max_vd_ndx = ivd.vd_ndx & VERSYM_VERSION;
11593
11594 off += ivd.vd_next;
11595 }
11596 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11597
11598 if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11599 {
11600 if (ivd.vd_ndx == 1 && ivd.vd_flags == VER_FLG_BASE)
11601 return NULL;
11602
11603 off -= ivd.vd_next;
11604 off += ivd.vd_aux;
11605
11606 if (get_data (&evda, filedata, off, sizeof (evda), 1,
11607 _("version def aux")) != NULL)
11608 {
11609 ivda.vda_name = BYTE_GET (evda.vda_name);
11610
11611 if (psym->st_name != ivda.vda_name)
11612 return (ivda.vda_name < strtab_size
11613 ? strtab + ivda.vda_name : _("<corrupt>"));
11614 }
11615 }
11616 }
11617
11618 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11619 {
11620 Elf_External_Verneed evn;
11621 Elf_Internal_Verneed ivn;
11622 Elf_Internal_Vernaux ivna;
11623
11624 offset = offset_from_vma (filedata,
11625 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11626 sizeof evn);
11627 do
11628 {
11629 unsigned long vna_off;
11630
11631 if (get_data (&evn, filedata, offset, sizeof (evn), 1,
11632 _("version need")) == NULL)
11633 {
11634 ivna.vna_next = 0;
11635 ivna.vna_other = 0;
11636 ivna.vna_name = 0;
11637 break;
11638 }
11639
11640 ivn.vn_aux = BYTE_GET (evn.vn_aux);
11641 ivn.vn_next = BYTE_GET (evn.vn_next);
11642
11643 vna_off = offset + ivn.vn_aux;
11644
11645 do
11646 {
11647 Elf_External_Vernaux evna;
11648
11649 if (get_data (&evna, filedata, vna_off, sizeof (evna), 1,
11650 _("version need aux (3)")) == NULL)
11651 {
11652 ivna.vna_next = 0;
11653 ivna.vna_other = 0;
11654 ivna.vna_name = 0;
11655 }
11656 else
11657 {
11658 ivna.vna_other = BYTE_GET (evna.vna_other);
11659 ivna.vna_next = BYTE_GET (evna.vna_next);
11660 ivna.vna_name = BYTE_GET (evna.vna_name);
11661 }
11662
11663 vna_off += ivna.vna_next;
11664 }
11665 while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11666
11667 if (ivna.vna_other == vers_data)
11668 break;
11669
11670 offset += ivn.vn_next;
11671 }
11672 while (ivn.vn_next != 0);
11673
11674 if (ivna.vna_other == vers_data)
11675 {
11676 *sym_info = symbol_undefined;
11677 *vna_other = ivna.vna_other;
11678 return (ivna.vna_name < strtab_size
11679 ? strtab + ivna.vna_name : _("<corrupt>"));
11680 }
11681 else if ((max_vd_ndx || (vers_data & VERSYM_VERSION) != 1)
11682 && (vers_data & VERSYM_VERSION) > max_vd_ndx)
11683 return _("<corrupt>");
11684 }
11685 return NULL;
11686 }
11687
11688 /* Dump the symbol table. */
11689 static bfd_boolean
process_symbol_table(Filedata * filedata)11690 process_symbol_table (Filedata * filedata)
11691 {
11692 Elf_Internal_Shdr * section;
11693 bfd_size_type nbuckets = 0;
11694 bfd_size_type nchains = 0;
11695 bfd_vma * buckets = NULL;
11696 bfd_vma * chains = NULL;
11697 bfd_vma ngnubuckets = 0;
11698 bfd_vma * gnubuckets = NULL;
11699 bfd_vma * gnuchains = NULL;
11700 bfd_vma * mipsxlat = NULL;
11701 bfd_vma gnusymidx = 0;
11702 bfd_size_type ngnuchains = 0;
11703
11704 if (!do_syms && !do_dyn_syms && !do_histogram)
11705 return TRUE;
11706
11707 if (dynamic_info[DT_HASH]
11708 && (do_histogram
11709 || (do_using_dynamic
11710 && !do_dyn_syms
11711 && dynamic_strings != NULL)))
11712 {
11713 unsigned char nb[8];
11714 unsigned char nc[8];
11715 unsigned int hash_ent_size = 4;
11716
11717 if ((filedata->file_header.e_machine == EM_ALPHA
11718 || filedata->file_header.e_machine == EM_S390
11719 || filedata->file_header.e_machine == EM_S390_OLD)
11720 && filedata->file_header.e_ident[EI_CLASS] == ELFCLASS64)
11721 hash_ent_size = 8;
11722
11723 if (fseek (filedata->handle,
11724 (archive_file_offset
11725 + offset_from_vma (filedata, dynamic_info[DT_HASH],
11726 sizeof nb + sizeof nc)),
11727 SEEK_SET))
11728 {
11729 error (_("Unable to seek to start of dynamic information\n"));
11730 goto no_hash;
11731 }
11732
11733 if (fread (nb, hash_ent_size, 1, filedata->handle) != 1)
11734 {
11735 error (_("Failed to read in number of buckets\n"));
11736 goto no_hash;
11737 }
11738
11739 if (fread (nc, hash_ent_size, 1, filedata->handle) != 1)
11740 {
11741 error (_("Failed to read in number of chains\n"));
11742 goto no_hash;
11743 }
11744
11745 nbuckets = byte_get (nb, hash_ent_size);
11746 nchains = byte_get (nc, hash_ent_size);
11747
11748 buckets = get_dynamic_data (filedata, nbuckets, hash_ent_size);
11749 chains = get_dynamic_data (filedata, nchains, hash_ent_size);
11750
11751 no_hash:
11752 if (buckets == NULL || chains == NULL)
11753 {
11754 if (do_using_dynamic)
11755 return FALSE;
11756 free (buckets);
11757 free (chains);
11758 buckets = NULL;
11759 chains = NULL;
11760 nbuckets = 0;
11761 nchains = 0;
11762 }
11763 }
11764
11765 if (dynamic_info_DT_GNU_HASH
11766 && (do_histogram
11767 || (do_using_dynamic
11768 && !do_dyn_syms
11769 && dynamic_strings != NULL)))
11770 {
11771 unsigned char nb[16];
11772 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11773 bfd_vma buckets_vma;
11774
11775 if (fseek (filedata->handle,
11776 (archive_file_offset
11777 + offset_from_vma (filedata, dynamic_info_DT_GNU_HASH,
11778 sizeof nb)),
11779 SEEK_SET))
11780 {
11781 error (_("Unable to seek to start of dynamic information\n"));
11782 goto no_gnu_hash;
11783 }
11784
11785 if (fread (nb, 16, 1, filedata->handle) != 1)
11786 {
11787 error (_("Failed to read in number of buckets\n"));
11788 goto no_gnu_hash;
11789 }
11790
11791 ngnubuckets = byte_get (nb, 4);
11792 gnusymidx = byte_get (nb + 4, 4);
11793 bitmaskwords = byte_get (nb + 8, 4);
11794 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11795 if (is_32bit_elf)
11796 buckets_vma += bitmaskwords * 4;
11797 else
11798 buckets_vma += bitmaskwords * 8;
11799
11800 if (fseek (filedata->handle,
11801 (archive_file_offset
11802 + offset_from_vma (filedata, buckets_vma, 4)),
11803 SEEK_SET))
11804 {
11805 error (_("Unable to seek to start of dynamic information\n"));
11806 goto no_gnu_hash;
11807 }
11808
11809 gnubuckets = get_dynamic_data (filedata, ngnubuckets, 4);
11810
11811 if (gnubuckets == NULL)
11812 goto no_gnu_hash;
11813
11814 for (i = 0; i < ngnubuckets; i++)
11815 if (gnubuckets[i] != 0)
11816 {
11817 if (gnubuckets[i] < gnusymidx)
11818 return FALSE;
11819
11820 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11821 maxchain = gnubuckets[i];
11822 }
11823
11824 if (maxchain == 0xffffffff)
11825 goto no_gnu_hash;
11826
11827 maxchain -= gnusymidx;
11828
11829 if (fseek (filedata->handle,
11830 (archive_file_offset
11831 + offset_from_vma (filedata, buckets_vma
11832 + 4 * (ngnubuckets + maxchain), 4)),
11833 SEEK_SET))
11834 {
11835 error (_("Unable to seek to start of dynamic information\n"));
11836 goto no_gnu_hash;
11837 }
11838
11839 do
11840 {
11841 if (fread (nb, 4, 1, filedata->handle) != 1)
11842 {
11843 error (_("Failed to determine last chain length\n"));
11844 goto no_gnu_hash;
11845 }
11846
11847 if (maxchain + 1 == 0)
11848 goto no_gnu_hash;
11849
11850 ++maxchain;
11851 }
11852 while ((byte_get (nb, 4) & 1) == 0);
11853
11854 if (fseek (filedata->handle,
11855 (archive_file_offset
11856 + offset_from_vma (filedata, buckets_vma + 4 * ngnubuckets, 4)),
11857 SEEK_SET))
11858 {
11859 error (_("Unable to seek to start of dynamic information\n"));
11860 goto no_gnu_hash;
11861 }
11862
11863 gnuchains = get_dynamic_data (filedata, maxchain, 4);
11864 ngnuchains = maxchain;
11865
11866 if (gnuchains == NULL)
11867 goto no_gnu_hash;
11868
11869 if (dynamic_info_DT_MIPS_XHASH)
11870 {
11871 if (fseek (filedata->handle,
11872 (archive_file_offset
11873 + offset_from_vma (filedata, (buckets_vma
11874 + 4 * (ngnubuckets
11875 + maxchain)), 4)),
11876 SEEK_SET))
11877 {
11878 error (_("Unable to seek to start of dynamic information\n"));
11879 goto no_gnu_hash;
11880 }
11881
11882 mipsxlat = get_dynamic_data (filedata, maxchain, 4);
11883 }
11884
11885 no_gnu_hash:
11886 if (dynamic_info_DT_MIPS_XHASH && mipsxlat == NULL)
11887 {
11888 free (gnuchains);
11889 gnuchains = NULL;
11890 }
11891 if (gnuchains == NULL)
11892 {
11893 free (gnubuckets);
11894 gnubuckets = NULL;
11895 ngnubuckets = 0;
11896 if (do_using_dynamic)
11897 return FALSE;
11898 }
11899 }
11900
11901 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11902 && do_syms
11903 && do_using_dynamic
11904 && dynamic_strings != NULL
11905 && dynamic_symbols != NULL)
11906 {
11907 unsigned long hn;
11908
11909 if (dynamic_info[DT_HASH])
11910 {
11911 bfd_vma si;
11912 char *visited;
11913
11914 printf (_("\nSymbol table for image:\n"));
11915 if (is_32bit_elf)
11916 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11917 else
11918 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11919
11920 visited = xcmalloc (nchains, 1);
11921 memset (visited, 0, nchains);
11922 for (hn = 0; hn < nbuckets; hn++)
11923 {
11924 for (si = buckets[hn]; si > 0; si = chains[si])
11925 {
11926 print_dynamic_symbol (filedata, si, hn);
11927 if (si >= nchains || visited[si])
11928 {
11929 error (_("histogram chain is corrupt\n"));
11930 break;
11931 }
11932 visited[si] = 1;
11933 }
11934 }
11935 free (visited);
11936 }
11937
11938 if (dynamic_info_DT_GNU_HASH)
11939 {
11940 printf (_("\nSymbol table of `%s' for image:\n"),
11941 GNU_HASH_SECTION_NAME);
11942 if (is_32bit_elf)
11943 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11944 else
11945 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11946
11947 for (hn = 0; hn < ngnubuckets; ++hn)
11948 if (gnubuckets[hn] != 0)
11949 {
11950 bfd_vma si = gnubuckets[hn];
11951 bfd_vma off = si - gnusymidx;
11952
11953 do
11954 {
11955 if (dynamic_info_DT_MIPS_XHASH)
11956 print_dynamic_symbol (filedata, mipsxlat[off], hn);
11957 else
11958 print_dynamic_symbol (filedata, si, hn);
11959 si++;
11960 }
11961 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11962 }
11963 }
11964 }
11965 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11966 && filedata->section_headers != NULL)
11967 {
11968 unsigned int i;
11969
11970 for (i = 0, section = filedata->section_headers;
11971 i < filedata->file_header.e_shnum;
11972 i++, section++)
11973 {
11974 unsigned int si;
11975 char * strtab = NULL;
11976 unsigned long int strtab_size = 0;
11977 Elf_Internal_Sym * symtab;
11978 Elf_Internal_Sym * psym;
11979 unsigned long num_syms;
11980
11981 if ((section->sh_type != SHT_SYMTAB
11982 && section->sh_type != SHT_DYNSYM)
11983 || (!do_syms
11984 && section->sh_type == SHT_SYMTAB))
11985 continue;
11986
11987 if (section->sh_entsize == 0)
11988 {
11989 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11990 printable_section_name (filedata, section));
11991 continue;
11992 }
11993
11994 num_syms = section->sh_size / section->sh_entsize;
11995 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11996 "\nSymbol table '%s' contains %lu entries:\n",
11997 num_syms),
11998 printable_section_name (filedata, section),
11999 num_syms);
12000
12001 if (is_32bit_elf)
12002 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12003 else
12004 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12005
12006 symtab = GET_ELF_SYMBOLS (filedata, section, & num_syms);
12007 if (symtab == NULL)
12008 continue;
12009
12010 if (section->sh_link == filedata->file_header.e_shstrndx)
12011 {
12012 strtab = filedata->string_table;
12013 strtab_size = filedata->string_table_length;
12014 }
12015 else if (section->sh_link < filedata->file_header.e_shnum)
12016 {
12017 Elf_Internal_Shdr * string_sec;
12018
12019 string_sec = filedata->section_headers + section->sh_link;
12020
12021 strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset,
12022 1, string_sec->sh_size,
12023 _("string table"));
12024 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
12025 }
12026
12027 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
12028 {
12029 const char *version_string;
12030 enum versioned_symbol_info sym_info;
12031 unsigned short vna_other;
12032
12033 printf ("%6d: ", si);
12034 print_vma (psym->st_value, LONG_HEX);
12035 putchar (' ');
12036 print_vma (psym->st_size, DEC_5);
12037 printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
12038 printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
12039 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
12040 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
12041 else
12042 {
12043 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
12044
12045 printf (" %-7s", get_symbol_visibility (vis));
12046 /* Check to see if any other bits in the st_other field are set.
12047 Note - displaying this information disrupts the layout of the
12048 table being generated, but for the moment this case is very rare. */
12049 if (psym->st_other ^ vis)
12050 printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
12051 }
12052 printf (" %4s ", get_symbol_index_type (filedata, psym->st_shndx));
12053 print_symbol (25, psym->st_name < strtab_size
12054 ? strtab + psym->st_name : _("<corrupt>"));
12055
12056 version_string
12057 = get_symbol_version_string (filedata,
12058 section->sh_type == SHT_DYNSYM,
12059 strtab, strtab_size, si,
12060 psym, &sym_info, &vna_other);
12061 if (version_string)
12062 {
12063 if (sym_info == symbol_undefined)
12064 printf ("@%s (%d)", version_string, vna_other);
12065 else
12066 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
12067 version_string);
12068 }
12069
12070 putchar ('\n');
12071
12072 if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
12073 && si >= section->sh_info
12074 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12075 && filedata->file_header.e_machine != EM_MIPS
12076 /* Solaris binaries have been found to violate this requirement as
12077 well. Not sure if this is a bug or an ABI requirement. */
12078 && filedata->file_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
12079 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
12080 si, printable_section_name (filedata, section), section->sh_info);
12081 }
12082
12083 free (symtab);
12084 if (strtab != filedata->string_table)
12085 free (strtab);
12086 }
12087 }
12088 else if (do_syms)
12089 printf
12090 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12091
12092 if (do_histogram && buckets != NULL)
12093 {
12094 unsigned long * lengths;
12095 unsigned long * counts;
12096 unsigned long hn;
12097 bfd_vma si;
12098 unsigned long maxlength = 0;
12099 unsigned long nzero_counts = 0;
12100 unsigned long nsyms = 0;
12101 char *visited;
12102
12103 printf (ngettext ("\nHistogram for bucket list length "
12104 "(total of %lu bucket):\n",
12105 "\nHistogram for bucket list length "
12106 "(total of %lu buckets):\n",
12107 (unsigned long) nbuckets),
12108 (unsigned long) nbuckets);
12109
12110 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
12111 if (lengths == NULL)
12112 {
12113 error (_("Out of memory allocating space for histogram buckets\n"));
12114 return FALSE;
12115 }
12116 visited = xcmalloc (nchains, 1);
12117 memset (visited, 0, nchains);
12118
12119 printf (_(" Length Number %% of total Coverage\n"));
12120 for (hn = 0; hn < nbuckets; ++hn)
12121 {
12122 for (si = buckets[hn]; si > 0; si = chains[si])
12123 {
12124 ++nsyms;
12125 if (maxlength < ++lengths[hn])
12126 ++maxlength;
12127 if (si >= nchains || visited[si])
12128 {
12129 error (_("histogram chain is corrupt\n"));
12130 break;
12131 }
12132 visited[si] = 1;
12133 }
12134 }
12135 free (visited);
12136
12137 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
12138 if (counts == NULL)
12139 {
12140 free (lengths);
12141 error (_("Out of memory allocating space for histogram counts\n"));
12142 return FALSE;
12143 }
12144
12145 for (hn = 0; hn < nbuckets; ++hn)
12146 ++counts[lengths[hn]];
12147
12148 if (nbuckets > 0)
12149 {
12150 unsigned long i;
12151 printf (" 0 %-10lu (%5.1f%%)\n",
12152 counts[0], (counts[0] * 100.0) / nbuckets);
12153 for (i = 1; i <= maxlength; ++i)
12154 {
12155 nzero_counts += counts[i] * i;
12156 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12157 i, counts[i], (counts[i] * 100.0) / nbuckets,
12158 (nzero_counts * 100.0) / nsyms);
12159 }
12160 }
12161
12162 free (counts);
12163 free (lengths);
12164 }
12165
12166 if (buckets != NULL)
12167 {
12168 free (buckets);
12169 free (chains);
12170 }
12171
12172 if (do_histogram && gnubuckets != NULL)
12173 {
12174 unsigned long * lengths;
12175 unsigned long * counts;
12176 unsigned long hn;
12177 unsigned long maxlength = 0;
12178 unsigned long nzero_counts = 0;
12179 unsigned long nsyms = 0;
12180
12181 printf (ngettext ("\nHistogram for `%s' bucket list length "
12182 "(total of %lu bucket):\n",
12183 "\nHistogram for `%s' bucket list length "
12184 "(total of %lu buckets):\n",
12185 (unsigned long) ngnubuckets),
12186 GNU_HASH_SECTION_NAME,
12187 (unsigned long) ngnubuckets);
12188
12189 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
12190 if (lengths == NULL)
12191 {
12192 error (_("Out of memory allocating space for gnu histogram buckets\n"));
12193 return FALSE;
12194 }
12195
12196 printf (_(" Length Number %% of total Coverage\n"));
12197
12198 for (hn = 0; hn < ngnubuckets; ++hn)
12199 if (gnubuckets[hn] != 0)
12200 {
12201 bfd_vma off, length = 1;
12202
12203 for (off = gnubuckets[hn] - gnusymidx;
12204 /* PR 17531 file: 010-77222-0.004. */
12205 off < ngnuchains && (gnuchains[off] & 1) == 0;
12206 ++off)
12207 ++length;
12208 lengths[hn] = length;
12209 if (length > maxlength)
12210 maxlength = length;
12211 nsyms += length;
12212 }
12213
12214 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
12215 if (counts == NULL)
12216 {
12217 free (lengths);
12218 error (_("Out of memory allocating space for gnu histogram counts\n"));
12219 return FALSE;
12220 }
12221
12222 for (hn = 0; hn < ngnubuckets; ++hn)
12223 ++counts[lengths[hn]];
12224
12225 if (ngnubuckets > 0)
12226 {
12227 unsigned long j;
12228 printf (" 0 %-10lu (%5.1f%%)\n",
12229 counts[0], (counts[0] * 100.0) / ngnubuckets);
12230 for (j = 1; j <= maxlength; ++j)
12231 {
12232 nzero_counts += counts[j] * j;
12233 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12234 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
12235 (nzero_counts * 100.0) / nsyms);
12236 }
12237 }
12238
12239 free (counts);
12240 free (lengths);
12241 free (gnubuckets);
12242 free (gnuchains);
12243 free (mipsxlat);
12244 }
12245
12246 return TRUE;
12247 }
12248
12249 static bfd_boolean
process_syminfo(Filedata * filedata ATTRIBUTE_UNUSED)12250 process_syminfo (Filedata * filedata ATTRIBUTE_UNUSED)
12251 {
12252 unsigned int i;
12253
12254 if (dynamic_syminfo == NULL
12255 || !do_dynamic)
12256 /* No syminfo, this is ok. */
12257 return TRUE;
12258
12259 /* There better should be a dynamic symbol section. */
12260 if (dynamic_symbols == NULL || dynamic_strings == NULL)
12261 return FALSE;
12262
12263 if (dynamic_addr)
12264 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12265 "contains %d entry:\n",
12266 "\nDynamic info segment at offset 0x%lx "
12267 "contains %d entries:\n",
12268 dynamic_syminfo_nent),
12269 dynamic_syminfo_offset, dynamic_syminfo_nent);
12270
12271 printf (_(" Num: Name BoundTo Flags\n"));
12272 for (i = 0; i < dynamic_syminfo_nent; ++i)
12273 {
12274 unsigned short int flags = dynamic_syminfo[i].si_flags;
12275
12276 printf ("%4d: ", i);
12277 if (i >= num_dynamic_syms)
12278 printf (_("<corrupt index>"));
12279 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
12280 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
12281 else
12282 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
12283 putchar (' ');
12284
12285 switch (dynamic_syminfo[i].si_boundto)
12286 {
12287 case SYMINFO_BT_SELF:
12288 fputs ("SELF ", stdout);
12289 break;
12290 case SYMINFO_BT_PARENT:
12291 fputs ("PARENT ", stdout);
12292 break;
12293 default:
12294 if (dynamic_syminfo[i].si_boundto > 0
12295 && dynamic_syminfo[i].si_boundto < dynamic_nent
12296 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
12297 {
12298 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
12299 putchar (' ' );
12300 }
12301 else
12302 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
12303 break;
12304 }
12305
12306 if (flags & SYMINFO_FLG_DIRECT)
12307 printf (" DIRECT");
12308 if (flags & SYMINFO_FLG_PASSTHRU)
12309 printf (" PASSTHRU");
12310 if (flags & SYMINFO_FLG_COPY)
12311 printf (" COPY");
12312 if (flags & SYMINFO_FLG_LAZYLOAD)
12313 printf (" LAZYLOAD");
12314
12315 puts ("");
12316 }
12317
12318 return TRUE;
12319 }
12320
12321 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
12322 is contained by the region START .. END. The types of ADDR, START
12323 and END should all be the same. Note both ADDR + NELEM and END
12324 point to just beyond the end of the regions that are being tested. */
12325 #define IN_RANGE(START,END,ADDR,NELEM) \
12326 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
12327
12328 /* Check to see if the given reloc needs to be handled in a target specific
12329 manner. If so then process the reloc and return TRUE otherwise return
12330 FALSE.
12331
12332 If called with reloc == NULL, then this is a signal that reloc processing
12333 for the current section has finished, and any saved state should be
12334 discarded. */
12335
12336 static bfd_boolean
target_specific_reloc_handling(Filedata * filedata,Elf_Internal_Rela * reloc,unsigned char * start,unsigned char * end,Elf_Internal_Sym * symtab,unsigned long num_syms)12337 target_specific_reloc_handling (Filedata * filedata,
12338 Elf_Internal_Rela * reloc,
12339 unsigned char * start,
12340 unsigned char * end,
12341 Elf_Internal_Sym * symtab,
12342 unsigned long num_syms)
12343 {
12344 unsigned int reloc_type = 0;
12345 unsigned long sym_index = 0;
12346
12347 if (reloc)
12348 {
12349 reloc_type = get_reloc_type (filedata, reloc->r_info);
12350 sym_index = get_reloc_symindex (reloc->r_info);
12351 }
12352
12353 switch (filedata->file_header.e_machine)
12354 {
12355 case EM_MSP430:
12356 case EM_MSP430_OLD:
12357 {
12358 static Elf_Internal_Sym * saved_sym = NULL;
12359
12360 if (reloc == NULL)
12361 {
12362 saved_sym = NULL;
12363 return TRUE;
12364 }
12365
12366 switch (reloc_type)
12367 {
12368 case 10: /* R_MSP430_SYM_DIFF */
12369 if (uses_msp430x_relocs (filedata))
12370 break;
12371 /* Fall through. */
12372 case 21: /* R_MSP430X_SYM_DIFF */
12373 /* PR 21139. */
12374 if (sym_index >= num_syms)
12375 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12376 sym_index);
12377 else
12378 saved_sym = symtab + sym_index;
12379 return TRUE;
12380
12381 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12382 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12383 goto handle_sym_diff;
12384
12385 case 5: /* R_MSP430_16_BYTE */
12386 case 9: /* R_MSP430_8 */
12387 if (uses_msp430x_relocs (filedata))
12388 break;
12389 goto handle_sym_diff;
12390
12391 case 2: /* R_MSP430_ABS16 */
12392 case 15: /* R_MSP430X_ABS16 */
12393 if (! uses_msp430x_relocs (filedata))
12394 break;
12395 goto handle_sym_diff;
12396
12397 handle_sym_diff:
12398 if (saved_sym != NULL)
12399 {
12400 int reloc_size = reloc_type == 1 ? 4 : 2;
12401 bfd_vma value;
12402
12403 if (sym_index >= num_syms)
12404 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12405 sym_index);
12406 else
12407 {
12408 value = reloc->r_addend + (symtab[sym_index].st_value
12409 - saved_sym->st_value);
12410
12411 if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12412 byte_put (start + reloc->r_offset, value, reloc_size);
12413 else
12414 /* PR 21137 */
12415 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12416 (long) reloc->r_offset);
12417 }
12418
12419 saved_sym = NULL;
12420 return TRUE;
12421 }
12422 break;
12423
12424 default:
12425 if (saved_sym != NULL)
12426 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12427 break;
12428 }
12429 break;
12430 }
12431
12432 case EM_MN10300:
12433 case EM_CYGNUS_MN10300:
12434 {
12435 static Elf_Internal_Sym * saved_sym = NULL;
12436
12437 if (reloc == NULL)
12438 {
12439 saved_sym = NULL;
12440 return TRUE;
12441 }
12442
12443 switch (reloc_type)
12444 {
12445 case 34: /* R_MN10300_ALIGN */
12446 return TRUE;
12447 case 33: /* R_MN10300_SYM_DIFF */
12448 if (sym_index >= num_syms)
12449 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12450 sym_index);
12451 else
12452 saved_sym = symtab + sym_index;
12453 return TRUE;
12454
12455 case 1: /* R_MN10300_32 */
12456 case 2: /* R_MN10300_16 */
12457 if (saved_sym != NULL)
12458 {
12459 int reloc_size = reloc_type == 1 ? 4 : 2;
12460 bfd_vma value;
12461
12462 if (sym_index >= num_syms)
12463 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12464 sym_index);
12465 else
12466 {
12467 value = reloc->r_addend + (symtab[sym_index].st_value
12468 - saved_sym->st_value);
12469
12470 if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12471 byte_put (start + reloc->r_offset, value, reloc_size);
12472 else
12473 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12474 (long) reloc->r_offset);
12475 }
12476
12477 saved_sym = NULL;
12478 return TRUE;
12479 }
12480 break;
12481 default:
12482 if (saved_sym != NULL)
12483 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12484 break;
12485 }
12486 break;
12487 }
12488
12489 case EM_RL78:
12490 {
12491 static bfd_vma saved_sym1 = 0;
12492 static bfd_vma saved_sym2 = 0;
12493 static bfd_vma value;
12494
12495 if (reloc == NULL)
12496 {
12497 saved_sym1 = saved_sym2 = 0;
12498 return TRUE;
12499 }
12500
12501 switch (reloc_type)
12502 {
12503 case 0x80: /* R_RL78_SYM. */
12504 saved_sym1 = saved_sym2;
12505 if (sym_index >= num_syms)
12506 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12507 sym_index);
12508 else
12509 {
12510 saved_sym2 = symtab[sym_index].st_value;
12511 saved_sym2 += reloc->r_addend;
12512 }
12513 return TRUE;
12514
12515 case 0x83: /* R_RL78_OPsub. */
12516 value = saved_sym1 - saved_sym2;
12517 saved_sym2 = saved_sym1 = 0;
12518 return TRUE;
12519 break;
12520
12521 case 0x41: /* R_RL78_ABS32. */
12522 if (IN_RANGE (start, end, start + reloc->r_offset, 4))
12523 byte_put (start + reloc->r_offset, value, 4);
12524 else
12525 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12526 (long) reloc->r_offset);
12527 value = 0;
12528 return TRUE;
12529
12530 case 0x43: /* R_RL78_ABS16. */
12531 if (IN_RANGE (start, end, start + reloc->r_offset, 2))
12532 byte_put (start + reloc->r_offset, value, 2);
12533 else
12534 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12535 (long) reloc->r_offset);
12536 value = 0;
12537 return TRUE;
12538
12539 default:
12540 break;
12541 }
12542 break;
12543 }
12544 }
12545
12546 return FALSE;
12547 }
12548
12549 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12550 DWARF debug sections. This is a target specific test. Note - we do not
12551 go through the whole including-target-headers-multiple-times route, (as
12552 we have already done with <elf/h8.h>) because this would become very
12553 messy and even then this function would have to contain target specific
12554 information (the names of the relocs instead of their numeric values).
12555 FIXME: This is not the correct way to solve this problem. The proper way
12556 is to have target specific reloc sizing and typing functions created by
12557 the reloc-macros.h header, in the same way that it already creates the
12558 reloc naming functions. */
12559
12560 static bfd_boolean
is_32bit_abs_reloc(Filedata * filedata,unsigned int reloc_type)12561 is_32bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12562 {
12563 /* Please keep this table alpha-sorted for ease of visual lookup. */
12564 switch (filedata->file_header.e_machine)
12565 {
12566 case EM_386:
12567 case EM_IAMCU:
12568 return reloc_type == 1; /* R_386_32. */
12569 case EM_68K:
12570 return reloc_type == 1; /* R_68K_32. */
12571 case EM_860:
12572 return reloc_type == 1; /* R_860_32. */
12573 case EM_960:
12574 return reloc_type == 2; /* R_960_32. */
12575 case EM_AARCH64:
12576 return (reloc_type == 258
12577 || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12578 case EM_BPF:
12579 return reloc_type == 11; /* R_BPF_DATA_32 */
12580 case EM_ADAPTEVA_EPIPHANY:
12581 return reloc_type == 3;
12582 case EM_ALPHA:
12583 return reloc_type == 1; /* R_ALPHA_REFLONG. */
12584 case EM_ARC:
12585 return reloc_type == 1; /* R_ARC_32. */
12586 case EM_ARC_COMPACT:
12587 case EM_ARC_COMPACT2:
12588 return reloc_type == 4; /* R_ARC_32. */
12589 case EM_ARM:
12590 return reloc_type == 2; /* R_ARM_ABS32 */
12591 case EM_AVR_OLD:
12592 case EM_AVR:
12593 return reloc_type == 1;
12594 case EM_BLACKFIN:
12595 return reloc_type == 0x12; /* R_byte4_data. */
12596 case EM_CRIS:
12597 return reloc_type == 3; /* R_CRIS_32. */
12598 case EM_CR16:
12599 return reloc_type == 3; /* R_CR16_NUM32. */
12600 case EM_CRX:
12601 return reloc_type == 15; /* R_CRX_NUM32. */
12602 case EM_CSKY:
12603 return reloc_type == 1; /* R_CKCORE_ADDR32. */
12604 case EM_CYGNUS_FRV:
12605 return reloc_type == 1;
12606 case EM_CYGNUS_D10V:
12607 case EM_D10V:
12608 return reloc_type == 6; /* R_D10V_32. */
12609 case EM_CYGNUS_D30V:
12610 case EM_D30V:
12611 return reloc_type == 12; /* R_D30V_32_NORMAL. */
12612 case EM_DLX:
12613 return reloc_type == 3; /* R_DLX_RELOC_32. */
12614 case EM_CYGNUS_FR30:
12615 case EM_FR30:
12616 return reloc_type == 3; /* R_FR30_32. */
12617 case EM_FT32:
12618 return reloc_type == 1; /* R_FT32_32. */
12619 case EM_H8S:
12620 case EM_H8_300:
12621 case EM_H8_300H:
12622 return reloc_type == 1; /* R_H8_DIR32. */
12623 case EM_IA_64:
12624 return (reloc_type == 0x64 /* R_IA64_SECREL32MSB. */
12625 || reloc_type == 0x65 /* R_IA64_SECREL32LSB. */
12626 || reloc_type == 0x24 /* R_IA64_DIR32MSB. */
12627 || reloc_type == 0x25 /* R_IA64_DIR32LSB. */);
12628 case EM_IP2K_OLD:
12629 case EM_IP2K:
12630 return reloc_type == 2; /* R_IP2K_32. */
12631 case EM_IQ2000:
12632 return reloc_type == 2; /* R_IQ2000_32. */
12633 case EM_LATTICEMICO32:
12634 return reloc_type == 3; /* R_LM32_32. */
12635 case EM_M32C_OLD:
12636 case EM_M32C:
12637 return reloc_type == 3; /* R_M32C_32. */
12638 case EM_M32R:
12639 return reloc_type == 34; /* R_M32R_32_RELA. */
12640 case EM_68HC11:
12641 case EM_68HC12:
12642 return reloc_type == 6; /* R_M68HC11_32. */
12643 case EM_S12Z:
12644 return reloc_type == 7 || /* R_S12Z_EXT32 */
12645 reloc_type == 6; /* R_S12Z_CW32. */
12646 case EM_MCORE:
12647 return reloc_type == 1; /* R_MCORE_ADDR32. */
12648 case EM_CYGNUS_MEP:
12649 return reloc_type == 4; /* R_MEP_32. */
12650 case EM_METAG:
12651 return reloc_type == 2; /* R_METAG_ADDR32. */
12652 case EM_MICROBLAZE:
12653 return reloc_type == 1; /* R_MICROBLAZE_32. */
12654 case EM_MIPS:
12655 return reloc_type == 2; /* R_MIPS_32. */
12656 case EM_MMIX:
12657 return reloc_type == 4; /* R_MMIX_32. */
12658 case EM_CYGNUS_MN10200:
12659 case EM_MN10200:
12660 return reloc_type == 1; /* R_MN10200_32. */
12661 case EM_CYGNUS_MN10300:
12662 case EM_MN10300:
12663 return reloc_type == 1; /* R_MN10300_32. */
12664 case EM_MOXIE:
12665 return reloc_type == 1; /* R_MOXIE_32. */
12666 case EM_MSP430_OLD:
12667 case EM_MSP430:
12668 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12669 case EM_MT:
12670 return reloc_type == 2; /* R_MT_32. */
12671 case EM_NDS32:
12672 return reloc_type == 20; /* R_NDS32_RELA. */
12673 case EM_ALTERA_NIOS2:
12674 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
12675 case EM_NIOS32:
12676 return reloc_type == 1; /* R_NIOS_32. */
12677 case EM_OR1K:
12678 return reloc_type == 1; /* R_OR1K_32. */
12679 case EM_PARISC:
12680 return (reloc_type == 1 /* R_PARISC_DIR32. */
12681 || reloc_type == 2 /* R_PARISC_DIR21L. */
12682 || reloc_type == 41); /* R_PARISC_SECREL32. */
12683 case EM_PJ:
12684 case EM_PJ_OLD:
12685 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
12686 case EM_PPC64:
12687 return reloc_type == 1; /* R_PPC64_ADDR32. */
12688 case EM_PPC:
12689 return reloc_type == 1; /* R_PPC_ADDR32. */
12690 case EM_TI_PRU:
12691 return reloc_type == 11; /* R_PRU_BFD_RELOC_32. */
12692 case EM_RISCV:
12693 return reloc_type == 1; /* R_RISCV_32. */
12694 case EM_RL78:
12695 return reloc_type == 1; /* R_RL78_DIR32. */
12696 case EM_RX:
12697 return reloc_type == 1; /* R_RX_DIR32. */
12698 case EM_S370:
12699 return reloc_type == 1; /* R_I370_ADDR31. */
12700 case EM_S390_OLD:
12701 case EM_S390:
12702 return reloc_type == 4; /* R_S390_32. */
12703 case EM_SCORE:
12704 return reloc_type == 8; /* R_SCORE_ABS32. */
12705 case EM_SH:
12706 return reloc_type == 1; /* R_SH_DIR32. */
12707 case EM_SPARC32PLUS:
12708 case EM_SPARCV9:
12709 case EM_SPARC:
12710 return reloc_type == 3 /* R_SPARC_32. */
12711 || reloc_type == 23; /* R_SPARC_UA32. */
12712 case EM_SPU:
12713 return reloc_type == 6; /* R_SPU_ADDR32 */
12714 case EM_TI_C6000:
12715 return reloc_type == 1; /* R_C6000_ABS32. */
12716 case EM_TILEGX:
12717 return reloc_type == 2; /* R_TILEGX_32. */
12718 case EM_TILEPRO:
12719 return reloc_type == 1; /* R_TILEPRO_32. */
12720 case EM_CYGNUS_V850:
12721 case EM_V850:
12722 return reloc_type == 6; /* R_V850_ABS32. */
12723 case EM_V800:
12724 return reloc_type == 0x33; /* R_V810_WORD. */
12725 case EM_VAX:
12726 return reloc_type == 1; /* R_VAX_32. */
12727 case EM_VISIUM:
12728 return reloc_type == 3; /* R_VISIUM_32. */
12729 case EM_WEBASSEMBLY:
12730 return reloc_type == 1; /* R_WASM32_32. */
12731 case EM_X86_64:
12732 case EM_L1OM:
12733 case EM_K1OM:
12734 return reloc_type == 10; /* R_X86_64_32. */
12735 case EM_XC16X:
12736 case EM_C166:
12737 return reloc_type == 3; /* R_XC16C_ABS_32. */
12738 case EM_XGATE:
12739 return reloc_type == 4; /* R_XGATE_32. */
12740 case EM_XSTORMY16:
12741 return reloc_type == 1; /* R_XSTROMY16_32. */
12742 case EM_XTENSA_OLD:
12743 case EM_XTENSA:
12744 return reloc_type == 1; /* R_XTENSA_32. */
12745 case EM_Z80:
12746 return reloc_type == 6; /* R_Z80_32. */
12747 default:
12748 {
12749 static unsigned int prev_warn = 0;
12750
12751 /* Avoid repeating the same warning multiple times. */
12752 if (prev_warn != filedata->file_header.e_machine)
12753 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12754 filedata->file_header.e_machine);
12755 prev_warn = filedata->file_header.e_machine;
12756 return FALSE;
12757 }
12758 }
12759 }
12760
12761 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12762 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12763
12764 static bfd_boolean
is_32bit_pcrel_reloc(Filedata * filedata,unsigned int reloc_type)12765 is_32bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12766 {
12767 switch (filedata->file_header.e_machine)
12768 /* Please keep this table alpha-sorted for ease of visual lookup. */
12769 {
12770 case EM_386:
12771 case EM_IAMCU:
12772 return reloc_type == 2; /* R_386_PC32. */
12773 case EM_68K:
12774 return reloc_type == 4; /* R_68K_PC32. */
12775 case EM_AARCH64:
12776 return reloc_type == 261; /* R_AARCH64_PREL32 */
12777 case EM_ADAPTEVA_EPIPHANY:
12778 return reloc_type == 6;
12779 case EM_ALPHA:
12780 return reloc_type == 10; /* R_ALPHA_SREL32. */
12781 case EM_ARC_COMPACT:
12782 case EM_ARC_COMPACT2:
12783 return reloc_type == 49; /* R_ARC_32_PCREL. */
12784 case EM_ARM:
12785 return reloc_type == 3; /* R_ARM_REL32 */
12786 case EM_AVR_OLD:
12787 case EM_AVR:
12788 return reloc_type == 36; /* R_AVR_32_PCREL. */
12789 case EM_MICROBLAZE:
12790 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
12791 case EM_OR1K:
12792 return reloc_type == 9; /* R_OR1K_32_PCREL. */
12793 case EM_PARISC:
12794 return reloc_type == 9; /* R_PARISC_PCREL32. */
12795 case EM_PPC:
12796 return reloc_type == 26; /* R_PPC_REL32. */
12797 case EM_PPC64:
12798 return reloc_type == 26; /* R_PPC64_REL32. */
12799 case EM_RISCV:
12800 return reloc_type == 57; /* R_RISCV_32_PCREL. */
12801 case EM_S390_OLD:
12802 case EM_S390:
12803 return reloc_type == 5; /* R_390_PC32. */
12804 case EM_SH:
12805 return reloc_type == 2; /* R_SH_REL32. */
12806 case EM_SPARC32PLUS:
12807 case EM_SPARCV9:
12808 case EM_SPARC:
12809 return reloc_type == 6; /* R_SPARC_DISP32. */
12810 case EM_SPU:
12811 return reloc_type == 13; /* R_SPU_REL32. */
12812 case EM_TILEGX:
12813 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
12814 case EM_TILEPRO:
12815 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
12816 case EM_VISIUM:
12817 return reloc_type == 6; /* R_VISIUM_32_PCREL */
12818 case EM_X86_64:
12819 case EM_L1OM:
12820 case EM_K1OM:
12821 return reloc_type == 2; /* R_X86_64_PC32. */
12822 case EM_VAX:
12823 return reloc_type == 4; /* R_VAX_PCREL32. */
12824 case EM_XTENSA_OLD:
12825 case EM_XTENSA:
12826 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
12827 default:
12828 /* Do not abort or issue an error message here. Not all targets use
12829 pc-relative 32-bit relocs in their DWARF debug information and we
12830 have already tested for target coverage in is_32bit_abs_reloc. A
12831 more helpful warning message will be generated by apply_relocations
12832 anyway, so just return. */
12833 return FALSE;
12834 }
12835 }
12836
12837 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12838 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12839
12840 static bfd_boolean
is_64bit_abs_reloc(Filedata * filedata,unsigned int reloc_type)12841 is_64bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12842 {
12843 switch (filedata->file_header.e_machine)
12844 {
12845 case EM_AARCH64:
12846 return reloc_type == 257; /* R_AARCH64_ABS64. */
12847 case EM_ALPHA:
12848 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
12849 case EM_IA_64:
12850 return (reloc_type == 0x26 /* R_IA64_DIR64MSB. */
12851 || reloc_type == 0x27 /* R_IA64_DIR64LSB. */);
12852 case EM_PARISC:
12853 return reloc_type == 80; /* R_PARISC_DIR64. */
12854 case EM_PPC64:
12855 return reloc_type == 38; /* R_PPC64_ADDR64. */
12856 case EM_RISCV:
12857 return reloc_type == 2; /* R_RISCV_64. */
12858 case EM_SPARC32PLUS:
12859 case EM_SPARCV9:
12860 case EM_SPARC:
12861 return reloc_type == 32 /* R_SPARC_64. */
12862 || reloc_type == 54; /* R_SPARC_UA64. */
12863 case EM_X86_64:
12864 case EM_L1OM:
12865 case EM_K1OM:
12866 return reloc_type == 1; /* R_X86_64_64. */
12867 case EM_S390_OLD:
12868 case EM_S390:
12869 return reloc_type == 22; /* R_S390_64. */
12870 case EM_TILEGX:
12871 return reloc_type == 1; /* R_TILEGX_64. */
12872 case EM_MIPS:
12873 return reloc_type == 18; /* R_MIPS_64. */
12874 default:
12875 return FALSE;
12876 }
12877 }
12878
12879 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12880 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12881
12882 static bfd_boolean
is_64bit_pcrel_reloc(Filedata * filedata,unsigned int reloc_type)12883 is_64bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12884 {
12885 switch (filedata->file_header.e_machine)
12886 {
12887 case EM_AARCH64:
12888 return reloc_type == 260; /* R_AARCH64_PREL64. */
12889 case EM_ALPHA:
12890 return reloc_type == 11; /* R_ALPHA_SREL64. */
12891 case EM_IA_64:
12892 return (reloc_type == 0x4e /* R_IA64_PCREL64MSB. */
12893 || reloc_type == 0x4f /* R_IA64_PCREL64LSB. */);
12894 case EM_PARISC:
12895 return reloc_type == 72; /* R_PARISC_PCREL64. */
12896 case EM_PPC64:
12897 return reloc_type == 44; /* R_PPC64_REL64. */
12898 case EM_SPARC32PLUS:
12899 case EM_SPARCV9:
12900 case EM_SPARC:
12901 return reloc_type == 46; /* R_SPARC_DISP64. */
12902 case EM_X86_64:
12903 case EM_L1OM:
12904 case EM_K1OM:
12905 return reloc_type == 24; /* R_X86_64_PC64. */
12906 case EM_S390_OLD:
12907 case EM_S390:
12908 return reloc_type == 23; /* R_S390_PC64. */
12909 case EM_TILEGX:
12910 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
12911 default:
12912 return FALSE;
12913 }
12914 }
12915
12916 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12917 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12918
12919 static bfd_boolean
is_24bit_abs_reloc(Filedata * filedata,unsigned int reloc_type)12920 is_24bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12921 {
12922 switch (filedata->file_header.e_machine)
12923 {
12924 case EM_CYGNUS_MN10200:
12925 case EM_MN10200:
12926 return reloc_type == 4; /* R_MN10200_24. */
12927 case EM_FT32:
12928 return reloc_type == 5; /* R_FT32_20. */
12929 case EM_Z80:
12930 return reloc_type == 5; /* R_Z80_24. */
12931 default:
12932 return FALSE;
12933 }
12934 }
12935
12936 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12937 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12938
12939 static bfd_boolean
is_16bit_abs_reloc(Filedata * filedata,unsigned int reloc_type)12940 is_16bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12941 {
12942 /* Please keep this table alpha-sorted for ease of visual lookup. */
12943 switch (filedata->file_header.e_machine)
12944 {
12945 case EM_ARC:
12946 case EM_ARC_COMPACT:
12947 case EM_ARC_COMPACT2:
12948 return reloc_type == 2; /* R_ARC_16. */
12949 case EM_ADAPTEVA_EPIPHANY:
12950 return reloc_type == 5;
12951 case EM_AVR_OLD:
12952 case EM_AVR:
12953 return reloc_type == 4; /* R_AVR_16. */
12954 case EM_CYGNUS_D10V:
12955 case EM_D10V:
12956 return reloc_type == 3; /* R_D10V_16. */
12957 case EM_FT32:
12958 return reloc_type == 2; /* R_FT32_16. */
12959 case EM_H8S:
12960 case EM_H8_300:
12961 case EM_H8_300H:
12962 return reloc_type == R_H8_DIR16;
12963 case EM_IP2K_OLD:
12964 case EM_IP2K:
12965 return reloc_type == 1; /* R_IP2K_16. */
12966 case EM_M32C_OLD:
12967 case EM_M32C:
12968 return reloc_type == 1; /* R_M32C_16 */
12969 case EM_CYGNUS_MN10200:
12970 case EM_MN10200:
12971 return reloc_type == 2; /* R_MN10200_16. */
12972 case EM_CYGNUS_MN10300:
12973 case EM_MN10300:
12974 return reloc_type == 2; /* R_MN10300_16. */
12975 case EM_MSP430:
12976 if (uses_msp430x_relocs (filedata))
12977 return reloc_type == 2; /* R_MSP430_ABS16. */
12978 /* Fall through. */
12979 case EM_MSP430_OLD:
12980 return reloc_type == 5; /* R_MSP430_16_BYTE. */
12981 case EM_NDS32:
12982 return reloc_type == 19; /* R_NDS32_RELA. */
12983 case EM_ALTERA_NIOS2:
12984 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
12985 case EM_NIOS32:
12986 return reloc_type == 9; /* R_NIOS_16. */
12987 case EM_OR1K:
12988 return reloc_type == 2; /* R_OR1K_16. */
12989 case EM_RISCV:
12990 return reloc_type == 55; /* R_RISCV_SET16. */
12991 case EM_TI_PRU:
12992 return reloc_type == 8; /* R_PRU_BFD_RELOC_16. */
12993 case EM_TI_C6000:
12994 return reloc_type == 2; /* R_C6000_ABS16. */
12995 case EM_VISIUM:
12996 return reloc_type == 2; /* R_VISIUM_16. */
12997 case EM_XC16X:
12998 case EM_C166:
12999 return reloc_type == 2; /* R_XC16C_ABS_16. */
13000 case EM_XGATE:
13001 return reloc_type == 3; /* R_XGATE_16. */
13002 case EM_Z80:
13003 return reloc_type == 4; /* R_Z80_16. */
13004 default:
13005 return FALSE;
13006 }
13007 }
13008
13009 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13010 a 8-bit absolute RELA relocation used in DWARF debug sections. */
13011
13012 static bfd_boolean
is_8bit_abs_reloc(Filedata * filedata,unsigned int reloc_type)13013 is_8bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
13014 {
13015 switch (filedata->file_header.e_machine)
13016 {
13017 case EM_RISCV:
13018 return reloc_type == 54; /* R_RISCV_SET8. */
13019 case EM_Z80:
13020 return reloc_type == 1; /* R_Z80_8. */
13021 default:
13022 return FALSE;
13023 }
13024 }
13025
13026 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13027 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13028
13029 static bfd_boolean
is_6bit_abs_reloc(Filedata * filedata,unsigned int reloc_type)13030 is_6bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
13031 {
13032 switch (filedata->file_header.e_machine)
13033 {
13034 case EM_RISCV:
13035 return reloc_type == 53; /* R_RISCV_SET6. */
13036 default:
13037 return FALSE;
13038 }
13039 }
13040
13041 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13042 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13043
13044 static bfd_boolean
is_32bit_inplace_add_reloc(Filedata * filedata,unsigned int reloc_type)13045 is_32bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13046 {
13047 /* Please keep this table alpha-sorted for ease of visual lookup. */
13048 switch (filedata->file_header.e_machine)
13049 {
13050 case EM_RISCV:
13051 return reloc_type == 35; /* R_RISCV_ADD32. */
13052 default:
13053 return FALSE;
13054 }
13055 }
13056
13057 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13058 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
13059
13060 static bfd_boolean
is_32bit_inplace_sub_reloc(Filedata * filedata,unsigned int reloc_type)13061 is_32bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13062 {
13063 /* Please keep this table alpha-sorted for ease of visual lookup. */
13064 switch (filedata->file_header.e_machine)
13065 {
13066 case EM_RISCV:
13067 return reloc_type == 39; /* R_RISCV_SUB32. */
13068 default:
13069 return FALSE;
13070 }
13071 }
13072
13073 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13074 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
13075
13076 static bfd_boolean
is_64bit_inplace_add_reloc(Filedata * filedata,unsigned int reloc_type)13077 is_64bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13078 {
13079 /* Please keep this table alpha-sorted for ease of visual lookup. */
13080 switch (filedata->file_header.e_machine)
13081 {
13082 case EM_RISCV:
13083 return reloc_type == 36; /* R_RISCV_ADD64. */
13084 default:
13085 return FALSE;
13086 }
13087 }
13088
13089 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13090 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13091
13092 static bfd_boolean
is_64bit_inplace_sub_reloc(Filedata * filedata,unsigned int reloc_type)13093 is_64bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13094 {
13095 /* Please keep this table alpha-sorted for ease of visual lookup. */
13096 switch (filedata->file_header.e_machine)
13097 {
13098 case EM_RISCV:
13099 return reloc_type == 40; /* R_RISCV_SUB64. */
13100 default:
13101 return FALSE;
13102 }
13103 }
13104
13105 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13106 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
13107
13108 static bfd_boolean
is_16bit_inplace_add_reloc(Filedata * filedata,unsigned int reloc_type)13109 is_16bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13110 {
13111 /* Please keep this table alpha-sorted for ease of visual lookup. */
13112 switch (filedata->file_header.e_machine)
13113 {
13114 case EM_RISCV:
13115 return reloc_type == 34; /* R_RISCV_ADD16. */
13116 default:
13117 return FALSE;
13118 }
13119 }
13120
13121 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13122 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
13123
13124 static bfd_boolean
is_16bit_inplace_sub_reloc(Filedata * filedata,unsigned int reloc_type)13125 is_16bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13126 {
13127 /* Please keep this table alpha-sorted for ease of visual lookup. */
13128 switch (filedata->file_header.e_machine)
13129 {
13130 case EM_RISCV:
13131 return reloc_type == 38; /* R_RISCV_SUB16. */
13132 default:
13133 return FALSE;
13134 }
13135 }
13136
13137 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13138 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
13139
13140 static bfd_boolean
is_8bit_inplace_add_reloc(Filedata * filedata,unsigned int reloc_type)13141 is_8bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
13142 {
13143 /* Please keep this table alpha-sorted for ease of visual lookup. */
13144 switch (filedata->file_header.e_machine)
13145 {
13146 case EM_RISCV:
13147 return reloc_type == 33; /* R_RISCV_ADD8. */
13148 default:
13149 return FALSE;
13150 }
13151 }
13152
13153 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13154 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
13155
13156 static bfd_boolean
is_8bit_inplace_sub_reloc(Filedata * filedata,unsigned int reloc_type)13157 is_8bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13158 {
13159 /* Please keep this table alpha-sorted for ease of visual lookup. */
13160 switch (filedata->file_header.e_machine)
13161 {
13162 case EM_RISCV:
13163 return reloc_type == 37; /* R_RISCV_SUB8. */
13164 default:
13165 return FALSE;
13166 }
13167 }
13168
13169 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13170 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
13171
13172 static bfd_boolean
is_6bit_inplace_sub_reloc(Filedata * filedata,unsigned int reloc_type)13173 is_6bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
13174 {
13175 switch (filedata->file_header.e_machine)
13176 {
13177 case EM_RISCV:
13178 return reloc_type == 52; /* R_RISCV_SUB6. */
13179 default:
13180 return FALSE;
13181 }
13182 }
13183
13184 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13185 relocation entries (possibly formerly used for SHT_GROUP sections). */
13186
13187 static bfd_boolean
is_none_reloc(Filedata * filedata,unsigned int reloc_type)13188 is_none_reloc (Filedata * filedata, unsigned int reloc_type)
13189 {
13190 switch (filedata->file_header.e_machine)
13191 {
13192 case EM_386: /* R_386_NONE. */
13193 case EM_68K: /* R_68K_NONE. */
13194 case EM_ADAPTEVA_EPIPHANY:
13195 case EM_ALPHA: /* R_ALPHA_NONE. */
13196 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
13197 case EM_ARC: /* R_ARC_NONE. */
13198 case EM_ARC_COMPACT2: /* R_ARC_NONE. */
13199 case EM_ARC_COMPACT: /* R_ARC_NONE. */
13200 case EM_ARM: /* R_ARM_NONE. */
13201 case EM_C166: /* R_XC16X_NONE. */
13202 case EM_CRIS: /* R_CRIS_NONE. */
13203 case EM_FT32: /* R_FT32_NONE. */
13204 case EM_IA_64: /* R_IA64_NONE. */
13205 case EM_K1OM: /* R_X86_64_NONE. */
13206 case EM_L1OM: /* R_X86_64_NONE. */
13207 case EM_M32R: /* R_M32R_NONE. */
13208 case EM_MIPS: /* R_MIPS_NONE. */
13209 case EM_MN10300: /* R_MN10300_NONE. */
13210 case EM_MOXIE: /* R_MOXIE_NONE. */
13211 case EM_NIOS32: /* R_NIOS_NONE. */
13212 case EM_OR1K: /* R_OR1K_NONE. */
13213 case EM_PARISC: /* R_PARISC_NONE. */
13214 case EM_PPC64: /* R_PPC64_NONE. */
13215 case EM_PPC: /* R_PPC_NONE. */
13216 case EM_RISCV: /* R_RISCV_NONE. */
13217 case EM_S390: /* R_390_NONE. */
13218 case EM_S390_OLD:
13219 case EM_SH: /* R_SH_NONE. */
13220 case EM_SPARC32PLUS:
13221 case EM_SPARC: /* R_SPARC_NONE. */
13222 case EM_SPARCV9:
13223 case EM_TILEGX: /* R_TILEGX_NONE. */
13224 case EM_TILEPRO: /* R_TILEPRO_NONE. */
13225 case EM_TI_C6000:/* R_C6000_NONE. */
13226 case EM_X86_64: /* R_X86_64_NONE. */
13227 case EM_XC16X:
13228 case EM_Z80: /* R_Z80_NONE. */
13229 case EM_WEBASSEMBLY: /* R_WASM32_NONE. */
13230 return reloc_type == 0;
13231
13232 case EM_AARCH64:
13233 return reloc_type == 0 || reloc_type == 256;
13234 case EM_AVR_OLD:
13235 case EM_AVR:
13236 return (reloc_type == 0 /* R_AVR_NONE. */
13237 || reloc_type == 30 /* R_AVR_DIFF8. */
13238 || reloc_type == 31 /* R_AVR_DIFF16. */
13239 || reloc_type == 32 /* R_AVR_DIFF32. */);
13240 case EM_METAG:
13241 return reloc_type == 3; /* R_METAG_NONE. */
13242 case EM_NDS32:
13243 return (reloc_type == 0 /* R_XTENSA_NONE. */
13244 || reloc_type == 204 /* R_NDS32_DIFF8. */
13245 || reloc_type == 205 /* R_NDS32_DIFF16. */
13246 || reloc_type == 206 /* R_NDS32_DIFF32. */
13247 || reloc_type == 207 /* R_NDS32_ULEB128. */);
13248 case EM_TI_PRU:
13249 return (reloc_type == 0 /* R_PRU_NONE. */
13250 || reloc_type == 65 /* R_PRU_DIFF8. */
13251 || reloc_type == 66 /* R_PRU_DIFF16. */
13252 || reloc_type == 67 /* R_PRU_DIFF32. */);
13253 case EM_XTENSA_OLD:
13254 case EM_XTENSA:
13255 return (reloc_type == 0 /* R_XTENSA_NONE. */
13256 || reloc_type == 17 /* R_XTENSA_DIFF8. */
13257 || reloc_type == 18 /* R_XTENSA_DIFF16. */
13258 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
13259 }
13260 return FALSE;
13261 }
13262
13263 /* Returns TRUE if there is a relocation against
13264 section NAME at OFFSET bytes. */
13265
13266 bfd_boolean
reloc_at(struct dwarf_section * dsec,dwarf_vma offset)13267 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
13268 {
13269 Elf_Internal_Rela * relocs;
13270 Elf_Internal_Rela * rp;
13271
13272 if (dsec == NULL || dsec->reloc_info == NULL)
13273 return FALSE;
13274
13275 relocs = (Elf_Internal_Rela *) dsec->reloc_info;
13276
13277 for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
13278 if (rp->r_offset == offset)
13279 return TRUE;
13280
13281 return FALSE;
13282 }
13283
13284 /* Apply relocations to a section.
13285 Returns TRUE upon success, FALSE otherwise.
13286 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13287 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13288 will be set to the number of relocs loaded.
13289
13290 Note: So far support has been added only for those relocations
13291 which can be found in debug sections. FIXME: Add support for
13292 more relocations ? */
13293
13294 static bfd_boolean
apply_relocations(Filedata * filedata,const Elf_Internal_Shdr * section,unsigned char * start,bfd_size_type size,void ** relocs_return,unsigned long * num_relocs_return)13295 apply_relocations (Filedata * filedata,
13296 const Elf_Internal_Shdr * section,
13297 unsigned char * start,
13298 bfd_size_type size,
13299 void ** relocs_return,
13300 unsigned long * num_relocs_return)
13301 {
13302 Elf_Internal_Shdr * relsec;
13303 unsigned char * end = start + size;
13304
13305 if (relocs_return != NULL)
13306 {
13307 * (Elf_Internal_Rela **) relocs_return = NULL;
13308 * num_relocs_return = 0;
13309 }
13310
13311 if (filedata->file_header.e_type != ET_REL)
13312 /* No relocs to apply. */
13313 return TRUE;
13314
13315 /* Find the reloc section associated with the section. */
13316 for (relsec = filedata->section_headers;
13317 relsec < filedata->section_headers + filedata->file_header.e_shnum;
13318 ++relsec)
13319 {
13320 bfd_boolean is_rela;
13321 unsigned long num_relocs;
13322 Elf_Internal_Rela * relocs;
13323 Elf_Internal_Rela * rp;
13324 Elf_Internal_Shdr * symsec;
13325 Elf_Internal_Sym * symtab;
13326 unsigned long num_syms;
13327 Elf_Internal_Sym * sym;
13328
13329 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13330 || relsec->sh_info >= filedata->file_header.e_shnum
13331 || filedata->section_headers + relsec->sh_info != section
13332 || relsec->sh_size == 0
13333 || relsec->sh_link >= filedata->file_header.e_shnum)
13334 continue;
13335
13336 symsec = filedata->section_headers + relsec->sh_link;
13337 if (symsec->sh_type != SHT_SYMTAB
13338 && symsec->sh_type != SHT_DYNSYM)
13339 return FALSE;
13340
13341 is_rela = relsec->sh_type == SHT_RELA;
13342
13343 if (is_rela)
13344 {
13345 if (!slurp_rela_relocs (filedata, relsec->sh_offset,
13346 relsec->sh_size, & relocs, & num_relocs))
13347 return FALSE;
13348 }
13349 else
13350 {
13351 if (!slurp_rel_relocs (filedata, relsec->sh_offset,
13352 relsec->sh_size, & relocs, & num_relocs))
13353 return FALSE;
13354 }
13355
13356 /* SH uses RELA but uses in place value instead of the addend field. */
13357 if (filedata->file_header.e_machine == EM_SH)
13358 is_rela = FALSE;
13359
13360 symtab = GET_ELF_SYMBOLS (filedata, symsec, & num_syms);
13361
13362 for (rp = relocs; rp < relocs + num_relocs; ++rp)
13363 {
13364 bfd_vma addend;
13365 unsigned int reloc_type;
13366 unsigned int reloc_size;
13367 bfd_boolean reloc_inplace = FALSE;
13368 bfd_boolean reloc_subtract = FALSE;
13369 unsigned char * rloc;
13370 unsigned long sym_index;
13371
13372 reloc_type = get_reloc_type (filedata, rp->r_info);
13373
13374 if (target_specific_reloc_handling (filedata, rp, start, end, symtab, num_syms))
13375 continue;
13376 else if (is_none_reloc (filedata, reloc_type))
13377 continue;
13378 else if (is_32bit_abs_reloc (filedata, reloc_type)
13379 || is_32bit_pcrel_reloc (filedata, reloc_type))
13380 reloc_size = 4;
13381 else if (is_64bit_abs_reloc (filedata, reloc_type)
13382 || is_64bit_pcrel_reloc (filedata, reloc_type))
13383 reloc_size = 8;
13384 else if (is_24bit_abs_reloc (filedata, reloc_type))
13385 reloc_size = 3;
13386 else if (is_16bit_abs_reloc (filedata, reloc_type))
13387 reloc_size = 2;
13388 else if (is_8bit_abs_reloc (filedata, reloc_type)
13389 || is_6bit_abs_reloc (filedata, reloc_type))
13390 reloc_size = 1;
13391 else if ((reloc_subtract = is_32bit_inplace_sub_reloc (filedata,
13392 reloc_type))
13393 || is_32bit_inplace_add_reloc (filedata, reloc_type))
13394 {
13395 reloc_size = 4;
13396 reloc_inplace = TRUE;
13397 }
13398 else if ((reloc_subtract = is_64bit_inplace_sub_reloc (filedata,
13399 reloc_type))
13400 || is_64bit_inplace_add_reloc (filedata, reloc_type))
13401 {
13402 reloc_size = 8;
13403 reloc_inplace = TRUE;
13404 }
13405 else if ((reloc_subtract = is_16bit_inplace_sub_reloc (filedata,
13406 reloc_type))
13407 || is_16bit_inplace_add_reloc (filedata, reloc_type))
13408 {
13409 reloc_size = 2;
13410 reloc_inplace = TRUE;
13411 }
13412 else if ((reloc_subtract = is_8bit_inplace_sub_reloc (filedata,
13413 reloc_type))
13414 || is_8bit_inplace_add_reloc (filedata, reloc_type))
13415 {
13416 reloc_size = 1;
13417 reloc_inplace = TRUE;
13418 }
13419 else if ((reloc_subtract = is_6bit_inplace_sub_reloc (filedata,
13420 reloc_type)))
13421 {
13422 reloc_size = 1;
13423 reloc_inplace = TRUE;
13424 }
13425 else
13426 {
13427 static unsigned int prev_reloc = 0;
13428
13429 if (reloc_type != prev_reloc)
13430 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13431 reloc_type, printable_section_name (filedata, section));
13432 prev_reloc = reloc_type;
13433 continue;
13434 }
13435
13436 rloc = start + rp->r_offset;
13437 if (!IN_RANGE (start, end, rloc, reloc_size))
13438 {
13439 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13440 (unsigned long) rp->r_offset,
13441 printable_section_name (filedata, section));
13442 continue;
13443 }
13444
13445 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
13446 if (sym_index >= num_syms)
13447 {
13448 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13449 sym_index, printable_section_name (filedata, section));
13450 continue;
13451 }
13452 sym = symtab + sym_index;
13453
13454 /* If the reloc has a symbol associated with it,
13455 make sure that it is of an appropriate type.
13456
13457 Relocations against symbols without type can happen.
13458 Gcc -feliminate-dwarf2-dups may generate symbols
13459 without type for debug info.
13460
13461 Icc generates relocations against function symbols
13462 instead of local labels.
13463
13464 Relocations against object symbols can happen, eg when
13465 referencing a global array. For an example of this see
13466 the _clz.o binary in libgcc.a. */
13467 if (sym != symtab
13468 && ELF_ST_TYPE (sym->st_info) != STT_COMMON
13469 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
13470 {
13471 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13472 get_symbol_type (filedata, ELF_ST_TYPE (sym->st_info)),
13473 printable_section_name (filedata, relsec),
13474 (long int)(rp - relocs));
13475 continue;
13476 }
13477
13478 addend = 0;
13479 if (is_rela)
13480 addend += rp->r_addend;
13481 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13482 partial_inplace. */
13483 if (!is_rela
13484 || (filedata->file_header.e_machine == EM_XTENSA
13485 && reloc_type == 1)
13486 || ((filedata->file_header.e_machine == EM_PJ
13487 || filedata->file_header.e_machine == EM_PJ_OLD)
13488 && reloc_type == 1)
13489 || ((filedata->file_header.e_machine == EM_D30V
13490 || filedata->file_header.e_machine == EM_CYGNUS_D30V)
13491 && reloc_type == 12)
13492 || reloc_inplace)
13493 {
13494 if (is_6bit_inplace_sub_reloc (filedata, reloc_type))
13495 addend += byte_get (rloc, reloc_size) & 0x3f;
13496 else
13497 addend += byte_get (rloc, reloc_size);
13498 }
13499
13500 if (is_32bit_pcrel_reloc (filedata, reloc_type)
13501 || is_64bit_pcrel_reloc (filedata, reloc_type))
13502 {
13503 /* On HPPA, all pc-relative relocations are biased by 8. */
13504 if (filedata->file_header.e_machine == EM_PARISC)
13505 addend -= 8;
13506 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
13507 reloc_size);
13508 }
13509 else if (is_6bit_abs_reloc (filedata, reloc_type)
13510 || is_6bit_inplace_sub_reloc (filedata, reloc_type))
13511 {
13512 if (reloc_subtract)
13513 addend -= sym->st_value;
13514 else
13515 addend += sym->st_value;
13516 addend = (addend & 0x3f) | (byte_get (rloc, reloc_size) & 0xc0);
13517 byte_put (rloc, addend, reloc_size);
13518 }
13519 else if (reloc_subtract)
13520 byte_put (rloc, addend - sym->st_value, reloc_size);
13521 else
13522 byte_put (rloc, addend + sym->st_value, reloc_size);
13523 }
13524
13525 free (symtab);
13526 /* Let the target specific reloc processing code know that
13527 we have finished with these relocs. */
13528 target_specific_reloc_handling (filedata, NULL, NULL, NULL, NULL, 0);
13529
13530 if (relocs_return)
13531 {
13532 * (Elf_Internal_Rela **) relocs_return = relocs;
13533 * num_relocs_return = num_relocs;
13534 }
13535 else
13536 free (relocs);
13537
13538 break;
13539 }
13540
13541 return TRUE;
13542 }
13543
13544 #ifdef SUPPORT_DISASSEMBLY
13545 static bfd_boolean
disassemble_section(Elf_Internal_Shdr * section,Filedata * filedata)13546 disassemble_section (Elf_Internal_Shdr * section, Filedata * filedata)
13547 {
13548 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata, section));
13549
13550 /* FIXME: XXX -- to be done --- XXX */
13551
13552 return TRUE;
13553 }
13554 #endif
13555
13556 /* Reads in the contents of SECTION from FILE, returning a pointer
13557 to a malloc'ed buffer or NULL if something went wrong. */
13558
13559 static char *
get_section_contents(Elf_Internal_Shdr * section,Filedata * filedata)13560 get_section_contents (Elf_Internal_Shdr * section, Filedata * filedata)
13561 {
13562 bfd_size_type num_bytes = section->sh_size;
13563
13564 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
13565 {
13566 printf (_("Section '%s' has no data to dump.\n"),
13567 printable_section_name (filedata, section));
13568 return NULL;
13569 }
13570
13571 return (char *) get_data (NULL, filedata, section->sh_offset, 1, num_bytes,
13572 _("section contents"));
13573 }
13574
13575 /* Uncompresses a section that was compressed using zlib, in place. */
13576
13577 static bfd_boolean
uncompress_section_contents(unsigned char ** buffer,dwarf_size_type uncompressed_size,dwarf_size_type * size)13578 uncompress_section_contents (unsigned char ** buffer,
13579 dwarf_size_type uncompressed_size,
13580 dwarf_size_type * size)
13581 {
13582 dwarf_size_type compressed_size = *size;
13583 unsigned char * compressed_buffer = *buffer;
13584 unsigned char * uncompressed_buffer;
13585 z_stream strm;
13586 int rc;
13587
13588 /* It is possible the section consists of several compressed
13589 buffers concatenated together, so we uncompress in a loop. */
13590 /* PR 18313: The state field in the z_stream structure is supposed
13591 to be invisible to the user (ie us), but some compilers will
13592 still complain about it being used without initialisation. So
13593 we first zero the entire z_stream structure and then set the fields
13594 that we need. */
13595 memset (& strm, 0, sizeof strm);
13596 strm.avail_in = compressed_size;
13597 strm.next_in = (Bytef *) compressed_buffer;
13598 strm.avail_out = uncompressed_size;
13599 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
13600
13601 rc = inflateInit (& strm);
13602 while (strm.avail_in > 0)
13603 {
13604 if (rc != Z_OK)
13605 goto fail;
13606 strm.next_out = ((Bytef *) uncompressed_buffer
13607 + (uncompressed_size - strm.avail_out));
13608 rc = inflate (&strm, Z_FINISH);
13609 if (rc != Z_STREAM_END)
13610 goto fail;
13611 rc = inflateReset (& strm);
13612 }
13613 rc = inflateEnd (& strm);
13614 if (rc != Z_OK
13615 || strm.avail_out != 0)
13616 goto fail;
13617
13618 *buffer = uncompressed_buffer;
13619 *size = uncompressed_size;
13620 return TRUE;
13621
13622 fail:
13623 free (uncompressed_buffer);
13624 /* Indicate decompression failure. */
13625 *buffer = NULL;
13626 return FALSE;
13627 }
13628
13629 static bfd_boolean
dump_section_as_strings(Elf_Internal_Shdr * section,Filedata * filedata)13630 dump_section_as_strings (Elf_Internal_Shdr * section, Filedata * filedata)
13631 {
13632 Elf_Internal_Shdr * relsec;
13633 bfd_size_type num_bytes;
13634 unsigned char * data;
13635 unsigned char * end;
13636 unsigned char * real_start;
13637 unsigned char * start;
13638 bfd_boolean some_strings_shown;
13639
13640 real_start = start = (unsigned char *) get_section_contents (section, filedata);
13641 if (start == NULL)
13642 /* PR 21820: Do not fail if the section was empty. */
13643 return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13644
13645 num_bytes = section->sh_size;
13646
13647 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata, section));
13648
13649 if (decompress_dumps)
13650 {
13651 dwarf_size_type new_size = num_bytes;
13652 dwarf_size_type uncompressed_size = 0;
13653
13654 if ((section->sh_flags & SHF_COMPRESSED) != 0)
13655 {
13656 Elf_Internal_Chdr chdr;
13657 unsigned int compression_header_size
13658 = get_compression_header (& chdr, (unsigned char *) start,
13659 num_bytes);
13660
13661 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13662 {
13663 warn (_("section '%s' has unsupported compress type: %d\n"),
13664 printable_section_name (filedata, section), chdr.ch_type);
13665 return FALSE;
13666 }
13667 uncompressed_size = chdr.ch_size;
13668 start += compression_header_size;
13669 new_size -= compression_header_size;
13670 }
13671 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13672 {
13673 /* Read the zlib header. In this case, it should be "ZLIB"
13674 followed by the uncompressed section size, 8 bytes in
13675 big-endian order. */
13676 uncompressed_size = start[4]; uncompressed_size <<= 8;
13677 uncompressed_size += start[5]; uncompressed_size <<= 8;
13678 uncompressed_size += start[6]; uncompressed_size <<= 8;
13679 uncompressed_size += start[7]; uncompressed_size <<= 8;
13680 uncompressed_size += start[8]; uncompressed_size <<= 8;
13681 uncompressed_size += start[9]; uncompressed_size <<= 8;
13682 uncompressed_size += start[10]; uncompressed_size <<= 8;
13683 uncompressed_size += start[11];
13684 start += 12;
13685 new_size -= 12;
13686 }
13687
13688 if (uncompressed_size)
13689 {
13690 if (uncompress_section_contents (& start,
13691 uncompressed_size, & new_size))
13692 num_bytes = new_size;
13693 else
13694 {
13695 error (_("Unable to decompress section %s\n"),
13696 printable_section_name (filedata, section));
13697 return FALSE;
13698 }
13699 }
13700 else
13701 start = real_start;
13702 }
13703
13704 /* If the section being dumped has relocations against it the user might
13705 be expecting these relocations to have been applied. Check for this
13706 case and issue a warning message in order to avoid confusion.
13707 FIXME: Maybe we ought to have an option that dumps a section with
13708 relocs applied ? */
13709 for (relsec = filedata->section_headers;
13710 relsec < filedata->section_headers + filedata->file_header.e_shnum;
13711 ++relsec)
13712 {
13713 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13714 || relsec->sh_info >= filedata->file_header.e_shnum
13715 || filedata->section_headers + relsec->sh_info != section
13716 || relsec->sh_size == 0
13717 || relsec->sh_link >= filedata->file_header.e_shnum)
13718 continue;
13719
13720 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13721 break;
13722 }
13723
13724 data = start;
13725 end = start + num_bytes;
13726 some_strings_shown = FALSE;
13727
13728 while (data < end)
13729 {
13730 while (!ISPRINT (* data))
13731 if (++ data >= end)
13732 break;
13733
13734 if (data < end)
13735 {
13736 size_t maxlen = end - data;
13737
13738 #ifndef __MSVCRT__
13739 /* PR 11128: Use two separate invocations in order to work
13740 around bugs in the Solaris 8 implementation of printf. */
13741 printf (" [%6tx] ", data - start);
13742 #else
13743 printf (" [%6Ix] ", (size_t) (data - start));
13744 #endif
13745 if (maxlen > 0)
13746 {
13747 print_symbol ((int) maxlen, (const char *) data);
13748 putchar ('\n');
13749 data += strnlen ((const char *) data, maxlen);
13750 }
13751 else
13752 {
13753 printf (_("<corrupt>\n"));
13754 data = end;
13755 }
13756 some_strings_shown = TRUE;
13757 }
13758 }
13759
13760 if (! some_strings_shown)
13761 printf (_(" No strings found in this section."));
13762
13763 free (real_start);
13764
13765 putchar ('\n');
13766 return TRUE;
13767 }
13768
13769 static bfd_boolean
dump_section_as_bytes(Elf_Internal_Shdr * section,Filedata * filedata,bfd_boolean relocate)13770 dump_section_as_bytes (Elf_Internal_Shdr * section,
13771 Filedata * filedata,
13772 bfd_boolean relocate)
13773 {
13774 Elf_Internal_Shdr * relsec;
13775 bfd_size_type bytes;
13776 bfd_size_type section_size;
13777 bfd_vma addr;
13778 unsigned char * data;
13779 unsigned char * real_start;
13780 unsigned char * start;
13781
13782 real_start = start = (unsigned char *) get_section_contents (section, filedata);
13783 if (start == NULL)
13784 /* PR 21820: Do not fail if the section was empty. */
13785 return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13786
13787 section_size = section->sh_size;
13788
13789 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata, section));
13790
13791 if (decompress_dumps)
13792 {
13793 dwarf_size_type new_size = section_size;
13794 dwarf_size_type uncompressed_size = 0;
13795
13796 if ((section->sh_flags & SHF_COMPRESSED) != 0)
13797 {
13798 Elf_Internal_Chdr chdr;
13799 unsigned int compression_header_size
13800 = get_compression_header (& chdr, start, section_size);
13801
13802 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13803 {
13804 warn (_("section '%s' has unsupported compress type: %d\n"),
13805 printable_section_name (filedata, section), chdr.ch_type);
13806 return FALSE;
13807 }
13808 uncompressed_size = chdr.ch_size;
13809 start += compression_header_size;
13810 new_size -= compression_header_size;
13811 }
13812 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13813 {
13814 /* Read the zlib header. In this case, it should be "ZLIB"
13815 followed by the uncompressed section size, 8 bytes in
13816 big-endian order. */
13817 uncompressed_size = start[4]; uncompressed_size <<= 8;
13818 uncompressed_size += start[5]; uncompressed_size <<= 8;
13819 uncompressed_size += start[6]; uncompressed_size <<= 8;
13820 uncompressed_size += start[7]; uncompressed_size <<= 8;
13821 uncompressed_size += start[8]; uncompressed_size <<= 8;
13822 uncompressed_size += start[9]; uncompressed_size <<= 8;
13823 uncompressed_size += start[10]; uncompressed_size <<= 8;
13824 uncompressed_size += start[11];
13825 start += 12;
13826 new_size -= 12;
13827 }
13828
13829 if (uncompressed_size)
13830 {
13831 if (uncompress_section_contents (& start, uncompressed_size,
13832 & new_size))
13833 {
13834 section_size = new_size;
13835 }
13836 else
13837 {
13838 error (_("Unable to decompress section %s\n"),
13839 printable_section_name (filedata, section));
13840 /* FIXME: Print the section anyway ? */
13841 return FALSE;
13842 }
13843 }
13844 else
13845 start = real_start;
13846 }
13847
13848 if (relocate)
13849 {
13850 if (! apply_relocations (filedata, section, start, section_size, NULL, NULL))
13851 return FALSE;
13852 }
13853 else
13854 {
13855 /* If the section being dumped has relocations against it the user might
13856 be expecting these relocations to have been applied. Check for this
13857 case and issue a warning message in order to avoid confusion.
13858 FIXME: Maybe we ought to have an option that dumps a section with
13859 relocs applied ? */
13860 for (relsec = filedata->section_headers;
13861 relsec < filedata->section_headers + filedata->file_header.e_shnum;
13862 ++relsec)
13863 {
13864 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13865 || relsec->sh_info >= filedata->file_header.e_shnum
13866 || filedata->section_headers + relsec->sh_info != section
13867 || relsec->sh_size == 0
13868 || relsec->sh_link >= filedata->file_header.e_shnum)
13869 continue;
13870
13871 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13872 break;
13873 }
13874 }
13875
13876 addr = section->sh_addr;
13877 bytes = section_size;
13878 data = start;
13879
13880 while (bytes)
13881 {
13882 int j;
13883 int k;
13884 int lbytes;
13885
13886 lbytes = (bytes > 16 ? 16 : bytes);
13887
13888 printf (" 0x%8.8lx ", (unsigned long) addr);
13889
13890 for (j = 0; j < 16; j++)
13891 {
13892 if (j < lbytes)
13893 printf ("%2.2x", data[j]);
13894 else
13895 printf (" ");
13896
13897 if ((j & 3) == 3)
13898 printf (" ");
13899 }
13900
13901 for (j = 0; j < lbytes; j++)
13902 {
13903 k = data[j];
13904 if (k >= ' ' && k < 0x7f)
13905 printf ("%c", k);
13906 else
13907 printf (".");
13908 }
13909
13910 putchar ('\n');
13911
13912 data += lbytes;
13913 addr += lbytes;
13914 bytes -= lbytes;
13915 }
13916
13917 free (real_start);
13918
13919 putchar ('\n');
13920 return TRUE;
13921 }
13922
13923 static ctf_sect_t *
shdr_to_ctf_sect(ctf_sect_t * buf,Elf_Internal_Shdr * shdr,Filedata * filedata)13924 shdr_to_ctf_sect (ctf_sect_t *buf, Elf_Internal_Shdr *shdr, Filedata *filedata)
13925 {
13926 buf->cts_name = SECTION_NAME (shdr);
13927 buf->cts_size = shdr->sh_size;
13928 buf->cts_entsize = shdr->sh_entsize;
13929
13930 return buf;
13931 }
13932
13933 /* Formatting callback function passed to ctf_dump. Returns either the pointer
13934 it is passed, or a pointer to newly-allocated storage, in which case
13935 dump_ctf() will free it when it no longer needs it. */
13936
dump_ctf_indent_lines(ctf_sect_names_t sect ATTRIBUTE_UNUSED,char * s,void * arg)13937 static char *dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED,
13938 char *s, void *arg)
13939 {
13940 const char *blanks = arg;
13941 char *new_s;
13942
13943 if (asprintf (&new_s, "%s%s", blanks, s) < 0)
13944 return s;
13945 return new_s;
13946 }
13947
13948 static bfd_boolean
dump_section_as_ctf(Elf_Internal_Shdr * section,Filedata * filedata)13949 dump_section_as_ctf (Elf_Internal_Shdr * section, Filedata * filedata)
13950 {
13951 Elf_Internal_Shdr * parent_sec = NULL;
13952 Elf_Internal_Shdr * symtab_sec = NULL;
13953 Elf_Internal_Shdr * strtab_sec = NULL;
13954 void * data = NULL;
13955 void * symdata = NULL;
13956 void * strdata = NULL;
13957 void * parentdata = NULL;
13958 ctf_sect_t ctfsect, symsect, strsect, parentsect;
13959 ctf_sect_t * symsectp = NULL;
13960 ctf_sect_t * strsectp = NULL;
13961 ctf_file_t * ctf = NULL;
13962 ctf_file_t * parent = NULL;
13963
13964 const char *things[] = {"Header", "Labels", "Data objects",
13965 "Function objects", "Variables", "Types", "Strings",
13966 ""};
13967 const char **thing;
13968 int err;
13969 bfd_boolean ret = FALSE;
13970 size_t i;
13971
13972 shdr_to_ctf_sect (&ctfsect, section, filedata);
13973 data = get_section_contents (section, filedata);
13974 ctfsect.cts_data = data;
13975
13976 if (!dump_ctf_symtab_name)
13977 dump_ctf_symtab_name = strdup (".symtab");
13978
13979 if (!dump_ctf_strtab_name)
13980 dump_ctf_strtab_name = strdup (".strtab");
13981
13982 if (dump_ctf_symtab_name && dump_ctf_symtab_name[0] != 0)
13983 {
13984 if ((symtab_sec = find_section (filedata, dump_ctf_symtab_name)) == NULL)
13985 {
13986 error (_("No symbol section named %s\n"), dump_ctf_symtab_name);
13987 goto fail;
13988 }
13989 if ((symdata = (void *) get_data (NULL, filedata,
13990 symtab_sec->sh_offset, 1,
13991 symtab_sec->sh_size,
13992 _("symbols"))) == NULL)
13993 goto fail;
13994 symsectp = shdr_to_ctf_sect (&symsect, symtab_sec, filedata);
13995 symsect.cts_data = symdata;
13996 }
13997 if (dump_ctf_strtab_name && dump_ctf_symtab_name[0] != 0)
13998 {
13999 if ((strtab_sec = find_section (filedata, dump_ctf_strtab_name)) == NULL)
14000 {
14001 error (_("No string table section named %s\n"),
14002 dump_ctf_strtab_name);
14003 goto fail;
14004 }
14005 if ((strdata = (void *) get_data (NULL, filedata,
14006 strtab_sec->sh_offset, 1,
14007 strtab_sec->sh_size,
14008 _("strings"))) == NULL)
14009 goto fail;
14010 strsectp = shdr_to_ctf_sect (&strsect, strtab_sec, filedata);
14011 strsect.cts_data = strdata;
14012 }
14013 if (dump_ctf_parent_name)
14014 {
14015 if ((parent_sec = find_section (filedata, dump_ctf_parent_name)) == NULL)
14016 {
14017 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name);
14018 goto fail;
14019 }
14020 if ((parentdata = (void *) get_data (NULL, filedata,
14021 parent_sec->sh_offset, 1,
14022 parent_sec->sh_size,
14023 _("CTF parent"))) == NULL)
14024 goto fail;
14025 shdr_to_ctf_sect (&parentsect, parent_sec, filedata);
14026 parentsect.cts_data = parentdata;
14027 }
14028
14029 /* Load the CTF file and dump it. */
14030
14031 if ((ctf = ctf_bufopen (&ctfsect, symsectp, strsectp, &err)) == NULL)
14032 {
14033 error (_("CTF open failure: %s\n"), ctf_errmsg (err));
14034 goto fail;
14035 }
14036
14037 if (parentdata)
14038 {
14039 if ((parent = ctf_bufopen (&parentsect, symsectp, strsectp, &err)) == NULL)
14040 {
14041 error (_("CTF open failure: %s\n"), ctf_errmsg (err));
14042 goto fail;
14043 }
14044
14045 ctf_import (ctf, parent);
14046 }
14047
14048 ret = TRUE;
14049
14050 printf (_("\nDump of CTF section '%s':\n"),
14051 printable_section_name (filedata, section));
14052
14053 for (i = 0, thing = things; *thing[0]; thing++, i++)
14054 {
14055 ctf_dump_state_t *s = NULL;
14056 char *item;
14057
14058 printf ("\n %s:\n", *thing);
14059 while ((item = ctf_dump (ctf, &s, i, dump_ctf_indent_lines,
14060 (void *) " ")) != NULL)
14061 {
14062 printf ("%s\n", item);
14063 free (item);
14064 }
14065
14066 if (ctf_errno (ctf))
14067 {
14068 error (_("Iteration failed: %s, %s\n"), *thing,
14069 ctf_errmsg (ctf_errno (ctf)));
14070 ret = FALSE;
14071 }
14072 }
14073
14074 fail:
14075 ctf_file_close (ctf);
14076 ctf_file_close (parent);
14077 free (parentdata);
14078 free (data);
14079 free (symdata);
14080 free (strdata);
14081 return ret;
14082 }
14083
14084 static bfd_boolean
load_specific_debug_section(enum dwarf_section_display_enum debug,const Elf_Internal_Shdr * sec,void * data)14085 load_specific_debug_section (enum dwarf_section_display_enum debug,
14086 const Elf_Internal_Shdr * sec,
14087 void * data)
14088 {
14089 struct dwarf_section * section = &debug_displays [debug].section;
14090 char buf [64];
14091 Filedata * filedata = (Filedata *) data;
14092
14093 if (section->start != NULL)
14094 {
14095 /* If it is already loaded, do nothing. */
14096 if (streq (section->filename, filedata->file_name))
14097 return TRUE;
14098 free (section->start);
14099 }
14100
14101 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
14102 section->address = sec->sh_addr;
14103 section->user_data = NULL;
14104 section->filename = filedata->file_name;
14105 section->start = (unsigned char *) get_data (NULL, filedata,
14106 sec->sh_offset, 1,
14107 sec->sh_size, buf);
14108 if (section->start == NULL)
14109 section->size = 0;
14110 else
14111 {
14112 unsigned char *start = section->start;
14113 dwarf_size_type size = sec->sh_size;
14114 dwarf_size_type uncompressed_size = 0;
14115
14116 if ((sec->sh_flags & SHF_COMPRESSED) != 0)
14117 {
14118 Elf_Internal_Chdr chdr;
14119 unsigned int compression_header_size;
14120
14121 if (size < (is_32bit_elf
14122 ? sizeof (Elf32_External_Chdr)
14123 : sizeof (Elf64_External_Chdr)))
14124 {
14125 warn (_("compressed section %s is too small to contain a compression header"),
14126 section->name);
14127 return FALSE;
14128 }
14129
14130 compression_header_size = get_compression_header (&chdr, start, size);
14131
14132 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
14133 {
14134 warn (_("section '%s' has unsupported compress type: %d\n"),
14135 section->name, chdr.ch_type);
14136 return FALSE;
14137 }
14138 uncompressed_size = chdr.ch_size;
14139 start += compression_header_size;
14140 size -= compression_header_size;
14141 }
14142 else if (size > 12 && streq ((char *) start, "ZLIB"))
14143 {
14144 /* Read the zlib header. In this case, it should be "ZLIB"
14145 followed by the uncompressed section size, 8 bytes in
14146 big-endian order. */
14147 uncompressed_size = start[4]; uncompressed_size <<= 8;
14148 uncompressed_size += start[5]; uncompressed_size <<= 8;
14149 uncompressed_size += start[6]; uncompressed_size <<= 8;
14150 uncompressed_size += start[7]; uncompressed_size <<= 8;
14151 uncompressed_size += start[8]; uncompressed_size <<= 8;
14152 uncompressed_size += start[9]; uncompressed_size <<= 8;
14153 uncompressed_size += start[10]; uncompressed_size <<= 8;
14154 uncompressed_size += start[11];
14155 start += 12;
14156 size -= 12;
14157 }
14158
14159 if (uncompressed_size)
14160 {
14161 if (uncompress_section_contents (&start, uncompressed_size,
14162 &size))
14163 {
14164 /* Free the compressed buffer, update the section buffer
14165 and the section size if uncompress is successful. */
14166 free (section->start);
14167 section->start = start;
14168 }
14169 else
14170 {
14171 error (_("Unable to decompress section %s\n"),
14172 printable_section_name (filedata, sec));
14173 return FALSE;
14174 }
14175 }
14176
14177 section->size = size;
14178 }
14179
14180 if (section->start == NULL)
14181 return FALSE;
14182
14183 if (debug_displays [debug].relocate)
14184 {
14185 if (! apply_relocations (filedata, sec, section->start, section->size,
14186 & section->reloc_info, & section->num_relocs))
14187 return FALSE;
14188 }
14189 else
14190 {
14191 section->reloc_info = NULL;
14192 section->num_relocs = 0;
14193 }
14194
14195 return TRUE;
14196 }
14197
14198 #if HAVE_LIBDEBUGINFOD
14199 /* Return a hex string representation of the build-id. */
14200 unsigned char *
get_build_id(void * data)14201 get_build_id (void * data)
14202 {
14203 Filedata * filedata = (Filedata *)data;
14204 Elf_Internal_Shdr * shdr;
14205 unsigned long i;
14206
14207 /* Iterate through notes to find note.gnu.build-id. */
14208 for (i = 0, shdr = filedata->section_headers;
14209 i < filedata->file_header.e_shnum && shdr != NULL;
14210 i++, shdr++)
14211 {
14212 if (shdr->sh_type != SHT_NOTE)
14213 continue;
14214
14215 char * next;
14216 char * end;
14217 size_t data_remaining;
14218 size_t min_notesz;
14219 Elf_External_Note * enote;
14220 Elf_Internal_Note inote;
14221
14222 bfd_vma offset = shdr->sh_offset;
14223 bfd_vma align = shdr->sh_addralign;
14224 bfd_vma length = shdr->sh_size;
14225
14226 enote = (Elf_External_Note *) get_section_contents (shdr, filedata);
14227 if (enote == NULL)
14228 continue;
14229
14230 if (align < 4)
14231 align = 4;
14232 else if (align != 4 && align != 8)
14233 continue;
14234
14235 end = (char *) enote + length;
14236 data_remaining = end - (char *) enote;
14237
14238 if (!is_ia64_vms (filedata))
14239 {
14240 min_notesz = offsetof (Elf_External_Note, name);
14241 if (data_remaining < min_notesz)
14242 {
14243 warn (ngettext ("debuginfod: Corrupt note: only %ld byte remains, "
14244 "not enough for a full note\n",
14245 "Corrupt note: only %ld bytes remain, "
14246 "not enough for a full note\n",
14247 data_remaining),
14248 (long) data_remaining);
14249 break;
14250 }
14251 data_remaining -= min_notesz;
14252
14253 inote.type = BYTE_GET (enote->type);
14254 inote.namesz = BYTE_GET (enote->namesz);
14255 inote.namedata = enote->name;
14256 inote.descsz = BYTE_GET (enote->descsz);
14257 inote.descdata = ((char *) enote
14258 + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
14259 inote.descpos = offset + (inote.descdata - (char *) enote);
14260 next = ((char *) enote
14261 + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
14262 }
14263 else
14264 {
14265 Elf64_External_VMS_Note *vms_enote;
14266
14267 /* PR binutils/15191
14268 Make sure that there is enough data to read. */
14269 min_notesz = offsetof (Elf64_External_VMS_Note, name);
14270 if (data_remaining < min_notesz)
14271 {
14272 warn (ngettext ("debuginfod: Corrupt note: only %ld byte remains, "
14273 "not enough for a full note\n",
14274 "Corrupt note: only %ld bytes remain, "
14275 "not enough for a full note\n",
14276 data_remaining),
14277 (long) data_remaining);
14278 break;
14279 }
14280 data_remaining -= min_notesz;
14281
14282 vms_enote = (Elf64_External_VMS_Note *) enote;
14283 inote.type = BYTE_GET (vms_enote->type);
14284 inote.namesz = BYTE_GET (vms_enote->namesz);
14285 inote.namedata = vms_enote->name;
14286 inote.descsz = BYTE_GET (vms_enote->descsz);
14287 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
14288 inote.descpos = offset + (inote.descdata - (char *) enote);
14289 next = inote.descdata + align_power (inote.descsz, 3);
14290 }
14291
14292 /* Skip malformed notes. */
14293 if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
14294 || (size_t) (inote.descdata - inote.namedata) > data_remaining
14295 || (size_t) (next - inote.descdata) < inote.descsz
14296 || ((size_t) (next - inote.descdata)
14297 > data_remaining - (size_t) (inote.descdata - inote.namedata)))
14298 {
14299 warn (_("debuginfod: note with invalid namesz and/or descsz found\n"));
14300 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
14301 inote.type, inote.namesz, inote.descsz, (int) align);
14302 continue;
14303 }
14304
14305 /* Check if this is the build-id note. If so then convert the build-id
14306 bytes to a hex string. */
14307 if (inote.namesz > 0
14308 && const_strneq (inote.namedata, "GNU")
14309 && inote.type == NT_GNU_BUILD_ID)
14310 {
14311 unsigned long j;
14312 char * build_id;
14313
14314 build_id = malloc (inote.descsz * 2 + 1);
14315 if (build_id == NULL)
14316 return NULL;
14317
14318 for (j = 0; j < inote.descsz; ++j)
14319 sprintf (build_id + (j * 2), "%02x", inote.descdata[j] & 0xff);
14320 build_id[inote.descsz * 2] = '\0';
14321
14322 return (unsigned char *)build_id;
14323 }
14324 }
14325
14326 return NULL;
14327 }
14328 #endif /* HAVE_LIBDEBUGINFOD */
14329
14330 /* If this is not NULL, load_debug_section will only look for sections
14331 within the list of sections given here. */
14332 static unsigned int * section_subset = NULL;
14333
14334 bfd_boolean
load_debug_section(enum dwarf_section_display_enum debug,void * data)14335 load_debug_section (enum dwarf_section_display_enum debug, void * data)
14336 {
14337 struct dwarf_section * section = &debug_displays [debug].section;
14338 Elf_Internal_Shdr * sec;
14339 Filedata * filedata = (Filedata *) data;
14340
14341 /* Without section headers we cannot find any sections. */
14342 if (filedata->section_headers == NULL)
14343 return FALSE;
14344
14345 if (filedata->string_table == NULL
14346 && filedata->file_header.e_shstrndx != SHN_UNDEF
14347 && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
14348 {
14349 Elf_Internal_Shdr * strs;
14350
14351 /* Read in the string table, so that we have section names to scan. */
14352 strs = filedata->section_headers + filedata->file_header.e_shstrndx;
14353
14354 if (strs != NULL && strs->sh_size != 0)
14355 {
14356 filedata->string_table
14357 = (char *) get_data (NULL, filedata, strs->sh_offset,
14358 1, strs->sh_size, _("string table"));
14359
14360 filedata->string_table_length
14361 = filedata->string_table != NULL ? strs->sh_size : 0;
14362 }
14363 }
14364
14365 /* Locate the debug section. */
14366 sec = find_section_in_set (filedata, section->uncompressed_name, section_subset);
14367 if (sec != NULL)
14368 section->name = section->uncompressed_name;
14369 else
14370 {
14371 sec = find_section_in_set (filedata, section->compressed_name, section_subset);
14372 if (sec != NULL)
14373 section->name = section->compressed_name;
14374 }
14375 if (sec == NULL)
14376 return FALSE;
14377
14378 /* If we're loading from a subset of sections, and we've loaded
14379 a section matching this name before, it's likely that it's a
14380 different one. */
14381 if (section_subset != NULL)
14382 free_debug_section (debug);
14383
14384 return load_specific_debug_section (debug, sec, data);
14385 }
14386
14387 void
free_debug_section(enum dwarf_section_display_enum debug)14388 free_debug_section (enum dwarf_section_display_enum debug)
14389 {
14390 struct dwarf_section * section = &debug_displays [debug].section;
14391
14392 if (section->start == NULL)
14393 return;
14394
14395 free ((char *) section->start);
14396 section->start = NULL;
14397 section->address = 0;
14398 section->size = 0;
14399
14400 if (section->reloc_info != NULL)
14401 {
14402 free (section->reloc_info);
14403 section->reloc_info = NULL;
14404 section->num_relocs = 0;
14405 }
14406 }
14407
14408 static bfd_boolean
display_debug_section(int shndx,Elf_Internal_Shdr * section,Filedata * filedata)14409 display_debug_section (int shndx, Elf_Internal_Shdr * section, Filedata * filedata)
14410 {
14411 char * name = SECTION_NAME (section);
14412 const char * print_name = printable_section_name (filedata, section);
14413 bfd_size_type length;
14414 bfd_boolean result = TRUE;
14415 int i;
14416
14417 length = section->sh_size;
14418 if (length == 0)
14419 {
14420 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
14421 return TRUE;
14422 }
14423 if (section->sh_type == SHT_NOBITS)
14424 {
14425 /* There is no point in dumping the contents of a debugging section
14426 which has the NOBITS type - the bits in the file will be random.
14427 This can happen when a file containing a .eh_frame section is
14428 stripped with the --only-keep-debug command line option. */
14429 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14430 print_name);
14431 return FALSE;
14432 }
14433
14434 if (const_strneq (name, ".gnu.linkonce.wi."))
14435 name = ".debug_info";
14436
14437 /* See if we know how to display the contents of this section. */
14438 for (i = 0; i < max; i++)
14439 {
14440 enum dwarf_section_display_enum id = (enum dwarf_section_display_enum) i;
14441 struct dwarf_section_display * display = debug_displays + i;
14442 struct dwarf_section * sec = & display->section;
14443
14444 if (streq (sec->uncompressed_name, name)
14445 || (id == line && const_strneq (name, ".debug_line."))
14446 || streq (sec->compressed_name, name))
14447 {
14448 bfd_boolean secondary = (section != find_section (filedata, name));
14449
14450 if (secondary)
14451 free_debug_section (id);
14452
14453 if (i == line && const_strneq (name, ".debug_line."))
14454 sec->name = name;
14455 else if (streq (sec->uncompressed_name, name))
14456 sec->name = sec->uncompressed_name;
14457 else
14458 sec->name = sec->compressed_name;
14459
14460 if (load_specific_debug_section (id, section, filedata))
14461 {
14462 /* If this debug section is part of a CU/TU set in a .dwp file,
14463 restrict load_debug_section to the sections in that set. */
14464 section_subset = find_cu_tu_set (filedata, shndx);
14465
14466 result &= display->display (sec, filedata);
14467
14468 section_subset = NULL;
14469
14470 if (secondary || (id != info && id != abbrev))
14471 free_debug_section (id);
14472 }
14473 break;
14474 }
14475 }
14476
14477 if (i == max)
14478 {
14479 printf (_("Unrecognized debug section: %s\n"), print_name);
14480 result = FALSE;
14481 }
14482
14483 return result;
14484 }
14485
14486 /* Set DUMP_SECTS for all sections where dumps were requested
14487 based on section name. */
14488
14489 static void
initialise_dumps_byname(Filedata * filedata)14490 initialise_dumps_byname (Filedata * filedata)
14491 {
14492 struct dump_list_entry * cur;
14493
14494 for (cur = dump_sects_byname; cur; cur = cur->next)
14495 {
14496 unsigned int i;
14497 bfd_boolean any = FALSE;
14498
14499 for (i = 0; i < filedata->file_header.e_shnum; i++)
14500 if (streq (SECTION_NAME (filedata->section_headers + i), cur->name))
14501 {
14502 request_dump_bynumber (filedata, i, cur->type);
14503 any = TRUE;
14504 }
14505
14506 if (!any)
14507 warn (_("Section '%s' was not dumped because it does not exist!\n"),
14508 cur->name);
14509 }
14510 }
14511
14512 static bfd_boolean
process_section_contents(Filedata * filedata)14513 process_section_contents (Filedata * filedata)
14514 {
14515 Elf_Internal_Shdr * section;
14516 unsigned int i;
14517 bfd_boolean res = TRUE;
14518
14519 if (! do_dump)
14520 return TRUE;
14521
14522 initialise_dumps_byname (filedata);
14523
14524 for (i = 0, section = filedata->section_headers;
14525 i < filedata->file_header.e_shnum && i < filedata->num_dump_sects;
14526 i++, section++)
14527 {
14528 dump_type dump = filedata->dump_sects[i];
14529
14530 #ifdef SUPPORT_DISASSEMBLY
14531 if (dump & DISASS_DUMP)
14532 {
14533 if (! disassemble_section (section, filedata))
14534 res = FALSE;
14535 }
14536 #endif
14537 if (dump & HEX_DUMP)
14538 {
14539 if (! dump_section_as_bytes (section, filedata, FALSE))
14540 res = FALSE;
14541 }
14542
14543 if (dump & RELOC_DUMP)
14544 {
14545 if (! dump_section_as_bytes (section, filedata, TRUE))
14546 res = FALSE;
14547 }
14548
14549 if (dump & STRING_DUMP)
14550 {
14551 if (! dump_section_as_strings (section, filedata))
14552 res = FALSE;
14553 }
14554
14555 if (dump & DEBUG_DUMP)
14556 {
14557 if (! display_debug_section (i, section, filedata))
14558 res = FALSE;
14559 }
14560
14561 if (dump & CTF_DUMP)
14562 {
14563 if (! dump_section_as_ctf (section, filedata))
14564 res = FALSE;
14565 }
14566 }
14567
14568 /* Check to see if the user requested a
14569 dump of a section that does not exist. */
14570 while (i < filedata->num_dump_sects)
14571 {
14572 if (filedata->dump_sects[i])
14573 {
14574 warn (_("Section %d was not dumped because it does not exist!\n"), i);
14575 res = FALSE;
14576 }
14577 i++;
14578 }
14579
14580 return res;
14581 }
14582
14583 static void
process_mips_fpe_exception(int mask)14584 process_mips_fpe_exception (int mask)
14585 {
14586 if (mask)
14587 {
14588 bfd_boolean first = TRUE;
14589
14590 if (mask & OEX_FPU_INEX)
14591 fputs ("INEX", stdout), first = FALSE;
14592 if (mask & OEX_FPU_UFLO)
14593 printf ("%sUFLO", first ? "" : "|"), first = FALSE;
14594 if (mask & OEX_FPU_OFLO)
14595 printf ("%sOFLO", first ? "" : "|"), first = FALSE;
14596 if (mask & OEX_FPU_DIV0)
14597 printf ("%sDIV0", first ? "" : "|"), first = FALSE;
14598 if (mask & OEX_FPU_INVAL)
14599 printf ("%sINVAL", first ? "" : "|");
14600 }
14601 else
14602 fputs ("0", stdout);
14603 }
14604
14605 /* Display's the value of TAG at location P. If TAG is
14606 greater than 0 it is assumed to be an unknown tag, and
14607 a message is printed to this effect. Otherwise it is
14608 assumed that a message has already been printed.
14609
14610 If the bottom bit of TAG is set it assumed to have a
14611 string value, otherwise it is assumed to have an integer
14612 value.
14613
14614 Returns an updated P pointing to the first unread byte
14615 beyond the end of TAG's value.
14616
14617 Reads at or beyond END will not be made. */
14618
14619 static unsigned char *
display_tag_value(signed int tag,unsigned char * p,const unsigned char * const end)14620 display_tag_value (signed int tag,
14621 unsigned char * p,
14622 const unsigned char * const end)
14623 {
14624 unsigned long val;
14625
14626 if (tag > 0)
14627 printf (" Tag_unknown_%d: ", tag);
14628
14629 if (p >= end)
14630 {
14631 warn (_("<corrupt tag>\n"));
14632 }
14633 else if (tag & 1)
14634 {
14635 /* PR 17531 file: 027-19978-0.004. */
14636 size_t maxlen = (end - p) - 1;
14637
14638 putchar ('"');
14639 if (maxlen > 0)
14640 {
14641 print_symbol ((int) maxlen, (const char *) p);
14642 p += strnlen ((char *) p, maxlen) + 1;
14643 }
14644 else
14645 {
14646 printf (_("<corrupt string tag>"));
14647 p = (unsigned char *) end;
14648 }
14649 printf ("\"\n");
14650 }
14651 else
14652 {
14653 READ_ULEB (val, p, end);
14654 printf ("%ld (0x%lx)\n", val, val);
14655 }
14656
14657 assert (p <= end);
14658 return p;
14659 }
14660
14661 /* ARC ABI attributes section. */
14662
14663 static unsigned char *
display_arc_attribute(unsigned char * p,const unsigned char * const end)14664 display_arc_attribute (unsigned char * p,
14665 const unsigned char * const end)
14666 {
14667 unsigned int tag;
14668 unsigned int val;
14669
14670 READ_ULEB (tag, p, end);
14671
14672 switch (tag)
14673 {
14674 case Tag_ARC_PCS_config:
14675 READ_ULEB (val, p, end);
14676 printf (" Tag_ARC_PCS_config: ");
14677 switch (val)
14678 {
14679 case 0:
14680 printf (_("Absent/Non standard\n"));
14681 break;
14682 case 1:
14683 printf (_("Bare metal/mwdt\n"));
14684 break;
14685 case 2:
14686 printf (_("Bare metal/newlib\n"));
14687 break;
14688 case 3:
14689 printf (_("Linux/uclibc\n"));
14690 break;
14691 case 4:
14692 printf (_("Linux/glibc\n"));
14693 break;
14694 default:
14695 printf (_("Unknown\n"));
14696 break;
14697 }
14698 break;
14699
14700 case Tag_ARC_CPU_base:
14701 READ_ULEB (val, p, end);
14702 printf (" Tag_ARC_CPU_base: ");
14703 switch (val)
14704 {
14705 default:
14706 case TAG_CPU_NONE:
14707 printf (_("Absent\n"));
14708 break;
14709 case TAG_CPU_ARC6xx:
14710 printf ("ARC6xx\n");
14711 break;
14712 case TAG_CPU_ARC7xx:
14713 printf ("ARC7xx\n");
14714 break;
14715 case TAG_CPU_ARCEM:
14716 printf ("ARCEM\n");
14717 break;
14718 case TAG_CPU_ARCHS:
14719 printf ("ARCHS\n");
14720 break;
14721 }
14722 break;
14723
14724 case Tag_ARC_CPU_variation:
14725 READ_ULEB (val, p, end);
14726 printf (" Tag_ARC_CPU_variation: ");
14727 switch (val)
14728 {
14729 default:
14730 if (val > 0 && val < 16)
14731 printf ("Core%d\n", val);
14732 else
14733 printf ("Unknown\n");
14734 break;
14735
14736 case 0:
14737 printf (_("Absent\n"));
14738 break;
14739 }
14740 break;
14741
14742 case Tag_ARC_CPU_name:
14743 printf (" Tag_ARC_CPU_name: ");
14744 p = display_tag_value (-1, p, end);
14745 break;
14746
14747 case Tag_ARC_ABI_rf16:
14748 READ_ULEB (val, p, end);
14749 printf (" Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
14750 break;
14751
14752 case Tag_ARC_ABI_osver:
14753 READ_ULEB (val, p, end);
14754 printf (" Tag_ARC_ABI_osver: v%d\n", val);
14755 break;
14756
14757 case Tag_ARC_ABI_pic:
14758 case Tag_ARC_ABI_sda:
14759 READ_ULEB (val, p, end);
14760 printf (tag == Tag_ARC_ABI_sda ? " Tag_ARC_ABI_sda: "
14761 : " Tag_ARC_ABI_pic: ");
14762 switch (val)
14763 {
14764 case 0:
14765 printf (_("Absent\n"));
14766 break;
14767 case 1:
14768 printf ("MWDT\n");
14769 break;
14770 case 2:
14771 printf ("GNU\n");
14772 break;
14773 default:
14774 printf (_("Unknown\n"));
14775 break;
14776 }
14777 break;
14778
14779 case Tag_ARC_ABI_tls:
14780 READ_ULEB (val, p, end);
14781 printf (" Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
14782 break;
14783
14784 case Tag_ARC_ABI_enumsize:
14785 READ_ULEB (val, p, end);
14786 printf (" Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
14787 _("smallest"));
14788 break;
14789
14790 case Tag_ARC_ABI_exceptions:
14791 READ_ULEB (val, p, end);
14792 printf (" Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
14793 : _("default"));
14794 break;
14795
14796 case Tag_ARC_ABI_double_size:
14797 READ_ULEB (val, p, end);
14798 printf (" Tag_ARC_ABI_double_size: %d\n", val);
14799 break;
14800
14801 case Tag_ARC_ISA_config:
14802 printf (" Tag_ARC_ISA_config: ");
14803 p = display_tag_value (-1, p, end);
14804 break;
14805
14806 case Tag_ARC_ISA_apex:
14807 printf (" Tag_ARC_ISA_apex: ");
14808 p = display_tag_value (-1, p, end);
14809 break;
14810
14811 case Tag_ARC_ISA_mpy_option:
14812 READ_ULEB (val, p, end);
14813 printf (" Tag_ARC_ISA_mpy_option: %d\n", val);
14814 break;
14815
14816 case Tag_ARC_ATR_version:
14817 READ_ULEB (val, p, end);
14818 printf (" Tag_ARC_ATR_version: %d\n", val);
14819 break;
14820
14821 default:
14822 return display_tag_value (tag & 1, p, end);
14823 }
14824
14825 return p;
14826 }
14827
14828 /* ARM EABI attributes section. */
14829 typedef struct
14830 {
14831 unsigned int tag;
14832 const char * name;
14833 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
14834 unsigned int type;
14835 const char ** table;
14836 } arm_attr_public_tag;
14837
14838 static const char * arm_attr_tag_CPU_arch[] =
14839 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14840 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14841 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
14842 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
14843 static const char * arm_attr_tag_THUMB_ISA_use[] =
14844 {"No", "Thumb-1", "Thumb-2", "Yes"};
14845 static const char * arm_attr_tag_FP_arch[] =
14846 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14847 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14848 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
14849 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
14850 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14851 "NEON for ARMv8.1"};
14852 static const char * arm_attr_tag_PCS_config[] =
14853 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14854 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14855 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
14856 {"V6", "SB", "TLS", "Unused"};
14857 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
14858 {"Absolute", "PC-relative", "SB-relative", "None"};
14859 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
14860 {"Absolute", "PC-relative", "None"};
14861 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
14862 {"None", "direct", "GOT-indirect"};
14863 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
14864 {"None", "??? 1", "2", "??? 3", "4"};
14865 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
14866 static const char * arm_attr_tag_ABI_FP_denormal[] =
14867 {"Unused", "Needed", "Sign only"};
14868 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
14869 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
14870 static const char * arm_attr_tag_ABI_FP_number_model[] =
14871 {"Unused", "Finite", "RTABI", "IEEE 754"};
14872 static const char * arm_attr_tag_ABI_enum_size[] =
14873 {"Unused", "small", "int", "forced to int"};
14874 static const char * arm_attr_tag_ABI_HardFP_use[] =
14875 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14876 static const char * arm_attr_tag_ABI_VFP_args[] =
14877 {"AAPCS", "VFP registers", "custom", "compatible"};
14878 static const char * arm_attr_tag_ABI_WMMX_args[] =
14879 {"AAPCS", "WMMX registers", "custom"};
14880 static const char * arm_attr_tag_ABI_optimization_goals[] =
14881 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14882 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14883 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
14884 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14885 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14886 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
14887 static const char * arm_attr_tag_FP_HP_extension[] =
14888 {"Not Allowed", "Allowed"};
14889 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
14890 {"None", "IEEE 754", "Alternative Format"};
14891 static const char * arm_attr_tag_DSP_extension[] =
14892 {"Follow architecture", "Allowed"};
14893 static const char * arm_attr_tag_MPextension_use[] =
14894 {"Not Allowed", "Allowed"};
14895 static const char * arm_attr_tag_DIV_use[] =
14896 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14897 "Allowed in v7-A with integer division extension"};
14898 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
14899 static const char * arm_attr_tag_Virtualization_use[] =
14900 {"Not Allowed", "TrustZone", "Virtualization Extensions",
14901 "TrustZone and Virtualization Extensions"};
14902 static const char * arm_attr_tag_MPextension_use_legacy[] =
14903 {"Not Allowed", "Allowed"};
14904
14905 static const char * arm_attr_tag_MVE_arch[] =
14906 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
14907
14908 #define LOOKUP(id, name) \
14909 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14910 static arm_attr_public_tag arm_attr_public_tags[] =
14911 {
14912 {4, "CPU_raw_name", 1, NULL},
14913 {5, "CPU_name", 1, NULL},
14914 LOOKUP(6, CPU_arch),
14915 {7, "CPU_arch_profile", 0, NULL},
14916 LOOKUP(8, ARM_ISA_use),
14917 LOOKUP(9, THUMB_ISA_use),
14918 LOOKUP(10, FP_arch),
14919 LOOKUP(11, WMMX_arch),
14920 LOOKUP(12, Advanced_SIMD_arch),
14921 LOOKUP(13, PCS_config),
14922 LOOKUP(14, ABI_PCS_R9_use),
14923 LOOKUP(15, ABI_PCS_RW_data),
14924 LOOKUP(16, ABI_PCS_RO_data),
14925 LOOKUP(17, ABI_PCS_GOT_use),
14926 LOOKUP(18, ABI_PCS_wchar_t),
14927 LOOKUP(19, ABI_FP_rounding),
14928 LOOKUP(20, ABI_FP_denormal),
14929 LOOKUP(21, ABI_FP_exceptions),
14930 LOOKUP(22, ABI_FP_user_exceptions),
14931 LOOKUP(23, ABI_FP_number_model),
14932 {24, "ABI_align_needed", 0, NULL},
14933 {25, "ABI_align_preserved", 0, NULL},
14934 LOOKUP(26, ABI_enum_size),
14935 LOOKUP(27, ABI_HardFP_use),
14936 LOOKUP(28, ABI_VFP_args),
14937 LOOKUP(29, ABI_WMMX_args),
14938 LOOKUP(30, ABI_optimization_goals),
14939 LOOKUP(31, ABI_FP_optimization_goals),
14940 {32, "compatibility", 0, NULL},
14941 LOOKUP(34, CPU_unaligned_access),
14942 LOOKUP(36, FP_HP_extension),
14943 LOOKUP(38, ABI_FP_16bit_format),
14944 LOOKUP(42, MPextension_use),
14945 LOOKUP(44, DIV_use),
14946 LOOKUP(46, DSP_extension),
14947 LOOKUP(48, MVE_arch),
14948 {64, "nodefaults", 0, NULL},
14949 {65, "also_compatible_with", 0, NULL},
14950 LOOKUP(66, T2EE_use),
14951 {67, "conformance", 1, NULL},
14952 LOOKUP(68, Virtualization_use),
14953 LOOKUP(70, MPextension_use_legacy)
14954 };
14955 #undef LOOKUP
14956
14957 static unsigned char *
display_arm_attribute(unsigned char * p,const unsigned char * const end)14958 display_arm_attribute (unsigned char * p,
14959 const unsigned char * const end)
14960 {
14961 unsigned int tag;
14962 unsigned int val;
14963 arm_attr_public_tag * attr;
14964 unsigned i;
14965 unsigned int type;
14966
14967 READ_ULEB (tag, p, end);
14968 attr = NULL;
14969 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
14970 {
14971 if (arm_attr_public_tags[i].tag == tag)
14972 {
14973 attr = &arm_attr_public_tags[i];
14974 break;
14975 }
14976 }
14977
14978 if (attr)
14979 {
14980 printf (" Tag_%s: ", attr->name);
14981 switch (attr->type)
14982 {
14983 case 0:
14984 switch (tag)
14985 {
14986 case 7: /* Tag_CPU_arch_profile. */
14987 READ_ULEB (val, p, end);
14988 switch (val)
14989 {
14990 case 0: printf (_("None\n")); break;
14991 case 'A': printf (_("Application\n")); break;
14992 case 'R': printf (_("Realtime\n")); break;
14993 case 'M': printf (_("Microcontroller\n")); break;
14994 case 'S': printf (_("Application or Realtime\n")); break;
14995 default: printf ("??? (%d)\n", val); break;
14996 }
14997 break;
14998
14999 case 24: /* Tag_align_needed. */
15000 READ_ULEB (val, p, end);
15001 switch (val)
15002 {
15003 case 0: printf (_("None\n")); break;
15004 case 1: printf (_("8-byte\n")); break;
15005 case 2: printf (_("4-byte\n")); break;
15006 case 3: printf ("??? 3\n"); break;
15007 default:
15008 if (val <= 12)
15009 printf (_("8-byte and up to %d-byte extended\n"),
15010 1 << val);
15011 else
15012 printf ("??? (%d)\n", val);
15013 break;
15014 }
15015 break;
15016
15017 case 25: /* Tag_align_preserved. */
15018 READ_ULEB (val, p, end);
15019 switch (val)
15020 {
15021 case 0: printf (_("None\n")); break;
15022 case 1: printf (_("8-byte, except leaf SP\n")); break;
15023 case 2: printf (_("8-byte\n")); break;
15024 case 3: printf ("??? 3\n"); break;
15025 default:
15026 if (val <= 12)
15027 printf (_("8-byte and up to %d-byte extended\n"),
15028 1 << val);
15029 else
15030 printf ("??? (%d)\n", val);
15031 break;
15032 }
15033 break;
15034
15035 case 32: /* Tag_compatibility. */
15036 {
15037 READ_ULEB (val, p, end);
15038 printf (_("flag = %d, vendor = "), val);
15039 if (p < end - 1)
15040 {
15041 size_t maxlen = (end - p) - 1;
15042
15043 print_symbol ((int) maxlen, (const char *) p);
15044 p += strnlen ((char *) p, maxlen) + 1;
15045 }
15046 else
15047 {
15048 printf (_("<corrupt>"));
15049 p = (unsigned char *) end;
15050 }
15051 putchar ('\n');
15052 }
15053 break;
15054
15055 case 64: /* Tag_nodefaults. */
15056 /* PR 17531: file: 001-505008-0.01. */
15057 if (p < end)
15058 p++;
15059 printf (_("True\n"));
15060 break;
15061
15062 case 65: /* Tag_also_compatible_with. */
15063 READ_ULEB (val, p, end);
15064 if (val == 6 /* Tag_CPU_arch. */)
15065 {
15066 READ_ULEB (val, p, end);
15067 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
15068 printf ("??? (%d)\n", val);
15069 else
15070 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
15071 }
15072 else
15073 printf ("???\n");
15074 while (p < end && *(p++) != '\0' /* NUL terminator. */)
15075 ;
15076 break;
15077
15078 default:
15079 printf (_("<unknown: %d>\n"), tag);
15080 break;
15081 }
15082 return p;
15083
15084 case 1:
15085 return display_tag_value (-1, p, end);
15086 case 2:
15087 return display_tag_value (0, p, end);
15088
15089 default:
15090 assert (attr->type & 0x80);
15091 READ_ULEB (val, p, end);
15092 type = attr->type & 0x7f;
15093 if (val >= type)
15094 printf ("??? (%d)\n", val);
15095 else
15096 printf ("%s\n", attr->table[val]);
15097 return p;
15098 }
15099 }
15100
15101 return display_tag_value (tag, p, end);
15102 }
15103
15104 static unsigned char *
display_gnu_attribute(unsigned char * p,unsigned char * (* display_proc_gnu_attribute)(unsigned char *,unsigned int,const unsigned char * const),const unsigned char * const end)15105 display_gnu_attribute (unsigned char * p,
15106 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
15107 const unsigned char * const end)
15108 {
15109 unsigned int tag;
15110 unsigned int val;
15111
15112 READ_ULEB (tag, p, end);
15113
15114 /* Tag_compatibility is the only generic GNU attribute defined at
15115 present. */
15116 if (tag == 32)
15117 {
15118 READ_ULEB (val, p, end);
15119
15120 printf (_("flag = %d, vendor = "), val);
15121 if (p == end)
15122 {
15123 printf (_("<corrupt>\n"));
15124 warn (_("corrupt vendor attribute\n"));
15125 }
15126 else
15127 {
15128 if (p < end - 1)
15129 {
15130 size_t maxlen = (end - p) - 1;
15131
15132 print_symbol ((int) maxlen, (const char *) p);
15133 p += strnlen ((char *) p, maxlen) + 1;
15134 }
15135 else
15136 {
15137 printf (_("<corrupt>"));
15138 p = (unsigned char *) end;
15139 }
15140 putchar ('\n');
15141 }
15142 return p;
15143 }
15144
15145 if ((tag & 2) == 0 && display_proc_gnu_attribute)
15146 return display_proc_gnu_attribute (p, tag, end);
15147
15148 return display_tag_value (tag, p, end);
15149 }
15150
15151 static unsigned char *
display_power_gnu_attribute(unsigned char * p,unsigned int tag,const unsigned char * const end)15152 display_power_gnu_attribute (unsigned char * p,
15153 unsigned int tag,
15154 const unsigned char * const end)
15155 {
15156 unsigned int val;
15157
15158 if (tag == Tag_GNU_Power_ABI_FP)
15159 {
15160 printf (" Tag_GNU_Power_ABI_FP: ");
15161 if (p == end)
15162 {
15163 printf (_("<corrupt>\n"));
15164 return p;
15165 }
15166 READ_ULEB (val, p, end);
15167
15168 if (val > 15)
15169 printf ("(%#x), ", val);
15170
15171 switch (val & 3)
15172 {
15173 case 0:
15174 printf (_("unspecified hard/soft float, "));
15175 break;
15176 case 1:
15177 printf (_("hard float, "));
15178 break;
15179 case 2:
15180 printf (_("soft float, "));
15181 break;
15182 case 3:
15183 printf (_("single-precision hard float, "));
15184 break;
15185 }
15186
15187 switch (val & 0xC)
15188 {
15189 case 0:
15190 printf (_("unspecified long double\n"));
15191 break;
15192 case 4:
15193 printf (_("128-bit IBM long double\n"));
15194 break;
15195 case 8:
15196 printf (_("64-bit long double\n"));
15197 break;
15198 case 12:
15199 printf (_("128-bit IEEE long double\n"));
15200 break;
15201 }
15202 return p;
15203 }
15204
15205 if (tag == Tag_GNU_Power_ABI_Vector)
15206 {
15207 printf (" Tag_GNU_Power_ABI_Vector: ");
15208 if (p == end)
15209 {
15210 printf (_("<corrupt>\n"));
15211 return p;
15212 }
15213 READ_ULEB (val, p, end);
15214
15215 if (val > 3)
15216 printf ("(%#x), ", val);
15217
15218 switch (val & 3)
15219 {
15220 case 0:
15221 printf (_("unspecified\n"));
15222 break;
15223 case 1:
15224 printf (_("generic\n"));
15225 break;
15226 case 2:
15227 printf ("AltiVec\n");
15228 break;
15229 case 3:
15230 printf ("SPE\n");
15231 break;
15232 }
15233 return p;
15234 }
15235
15236 if (tag == Tag_GNU_Power_ABI_Struct_Return)
15237 {
15238 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
15239 if (p == end)
15240 {
15241 printf (_("<corrupt>\n"));
15242 return p;
15243 }
15244 READ_ULEB (val, p, end);
15245
15246 if (val > 2)
15247 printf ("(%#x), ", val);
15248
15249 switch (val & 3)
15250 {
15251 case 0:
15252 printf (_("unspecified\n"));
15253 break;
15254 case 1:
15255 printf ("r3/r4\n");
15256 break;
15257 case 2:
15258 printf (_("memory\n"));
15259 break;
15260 case 3:
15261 printf ("???\n");
15262 break;
15263 }
15264 return p;
15265 }
15266
15267 return display_tag_value (tag & 1, p, end);
15268 }
15269
15270 static unsigned char *
display_s390_gnu_attribute(unsigned char * p,unsigned int tag,const unsigned char * const end)15271 display_s390_gnu_attribute (unsigned char * p,
15272 unsigned int tag,
15273 const unsigned char * const end)
15274 {
15275 unsigned int val;
15276
15277 if (tag == Tag_GNU_S390_ABI_Vector)
15278 {
15279 printf (" Tag_GNU_S390_ABI_Vector: ");
15280 READ_ULEB (val, p, end);
15281
15282 switch (val)
15283 {
15284 case 0:
15285 printf (_("any\n"));
15286 break;
15287 case 1:
15288 printf (_("software\n"));
15289 break;
15290 case 2:
15291 printf (_("hardware\n"));
15292 break;
15293 default:
15294 printf ("??? (%d)\n", val);
15295 break;
15296 }
15297 return p;
15298 }
15299
15300 return display_tag_value (tag & 1, p, end);
15301 }
15302
15303 static void
display_sparc_hwcaps(unsigned int mask)15304 display_sparc_hwcaps (unsigned int mask)
15305 {
15306 if (mask)
15307 {
15308 bfd_boolean first = TRUE;
15309
15310 if (mask & ELF_SPARC_HWCAP_MUL32)
15311 fputs ("mul32", stdout), first = FALSE;
15312 if (mask & ELF_SPARC_HWCAP_DIV32)
15313 printf ("%sdiv32", first ? "" : "|"), first = FALSE;
15314 if (mask & ELF_SPARC_HWCAP_FSMULD)
15315 printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
15316 if (mask & ELF_SPARC_HWCAP_V8PLUS)
15317 printf ("%sv8plus", first ? "" : "|"), first = FALSE;
15318 if (mask & ELF_SPARC_HWCAP_POPC)
15319 printf ("%spopc", first ? "" : "|"), first = FALSE;
15320 if (mask & ELF_SPARC_HWCAP_VIS)
15321 printf ("%svis", first ? "" : "|"), first = FALSE;
15322 if (mask & ELF_SPARC_HWCAP_VIS2)
15323 printf ("%svis2", first ? "" : "|"), first = FALSE;
15324 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
15325 printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
15326 if (mask & ELF_SPARC_HWCAP_FMAF)
15327 printf ("%sfmaf", first ? "" : "|"), first = FALSE;
15328 if (mask & ELF_SPARC_HWCAP_VIS3)
15329 printf ("%svis3", first ? "" : "|"), first = FALSE;
15330 if (mask & ELF_SPARC_HWCAP_HPC)
15331 printf ("%shpc", first ? "" : "|"), first = FALSE;
15332 if (mask & ELF_SPARC_HWCAP_RANDOM)
15333 printf ("%srandom", first ? "" : "|"), first = FALSE;
15334 if (mask & ELF_SPARC_HWCAP_TRANS)
15335 printf ("%strans", first ? "" : "|"), first = FALSE;
15336 if (mask & ELF_SPARC_HWCAP_FJFMAU)
15337 printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
15338 if (mask & ELF_SPARC_HWCAP_IMA)
15339 printf ("%sima", first ? "" : "|"), first = FALSE;
15340 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
15341 printf ("%scspare", first ? "" : "|"), first = FALSE;
15342 }
15343 else
15344 fputc ('0', stdout);
15345 fputc ('\n', stdout);
15346 }
15347
15348 static void
display_sparc_hwcaps2(unsigned int mask)15349 display_sparc_hwcaps2 (unsigned int mask)
15350 {
15351 if (mask)
15352 {
15353 bfd_boolean first = TRUE;
15354
15355 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
15356 fputs ("fjathplus", stdout), first = FALSE;
15357 if (mask & ELF_SPARC_HWCAP2_VIS3B)
15358 printf ("%svis3b", first ? "" : "|"), first = FALSE;
15359 if (mask & ELF_SPARC_HWCAP2_ADP)
15360 printf ("%sadp", first ? "" : "|"), first = FALSE;
15361 if (mask & ELF_SPARC_HWCAP2_SPARC5)
15362 printf ("%ssparc5", first ? "" : "|"), first = FALSE;
15363 if (mask & ELF_SPARC_HWCAP2_MWAIT)
15364 printf ("%smwait", first ? "" : "|"), first = FALSE;
15365 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
15366 printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
15367 if (mask & ELF_SPARC_HWCAP2_XMONT)
15368 printf ("%sxmont2", first ? "" : "|"), first = FALSE;
15369 if (mask & ELF_SPARC_HWCAP2_NSEC)
15370 printf ("%snsec", first ? "" : "|"), first = FALSE;
15371 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
15372 printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
15373 if (mask & ELF_SPARC_HWCAP2_FJDES)
15374 printf ("%sfjdes", first ? "" : "|"), first = FALSE;
15375 if (mask & ELF_SPARC_HWCAP2_FJAES)
15376 printf ("%sfjaes", first ? "" : "|"), first = FALSE;
15377 }
15378 else
15379 fputc ('0', stdout);
15380 fputc ('\n', stdout);
15381 }
15382
15383 static unsigned char *
display_sparc_gnu_attribute(unsigned char * p,unsigned int tag,const unsigned char * const end)15384 display_sparc_gnu_attribute (unsigned char * p,
15385 unsigned int tag,
15386 const unsigned char * const end)
15387 {
15388 unsigned int val;
15389
15390 if (tag == Tag_GNU_Sparc_HWCAPS)
15391 {
15392 READ_ULEB (val, p, end);
15393 printf (" Tag_GNU_Sparc_HWCAPS: ");
15394 display_sparc_hwcaps (val);
15395 return p;
15396 }
15397 if (tag == Tag_GNU_Sparc_HWCAPS2)
15398 {
15399 READ_ULEB (val, p, end);
15400 printf (" Tag_GNU_Sparc_HWCAPS2: ");
15401 display_sparc_hwcaps2 (val);
15402 return p;
15403 }
15404
15405 return display_tag_value (tag, p, end);
15406 }
15407
15408 static void
print_mips_fp_abi_value(unsigned int val)15409 print_mips_fp_abi_value (unsigned int val)
15410 {
15411 switch (val)
15412 {
15413 case Val_GNU_MIPS_ABI_FP_ANY:
15414 printf (_("Hard or soft float\n"));
15415 break;
15416 case Val_GNU_MIPS_ABI_FP_DOUBLE:
15417 printf (_("Hard float (double precision)\n"));
15418 break;
15419 case Val_GNU_MIPS_ABI_FP_SINGLE:
15420 printf (_("Hard float (single precision)\n"));
15421 break;
15422 case Val_GNU_MIPS_ABI_FP_SOFT:
15423 printf (_("Soft float\n"));
15424 break;
15425 case Val_GNU_MIPS_ABI_FP_OLD_64:
15426 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15427 break;
15428 case Val_GNU_MIPS_ABI_FP_XX:
15429 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15430 break;
15431 case Val_GNU_MIPS_ABI_FP_64:
15432 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15433 break;
15434 case Val_GNU_MIPS_ABI_FP_64A:
15435 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15436 break;
15437 case Val_GNU_MIPS_ABI_FP_NAN2008:
15438 printf (_("NaN 2008 compatibility\n"));
15439 break;
15440 default:
15441 printf ("??? (%d)\n", val);
15442 break;
15443 }
15444 }
15445
15446 static unsigned char *
display_mips_gnu_attribute(unsigned char * p,unsigned int tag,const unsigned char * const end)15447 display_mips_gnu_attribute (unsigned char * p,
15448 unsigned int tag,
15449 const unsigned char * const end)
15450 {
15451 if (tag == Tag_GNU_MIPS_ABI_FP)
15452 {
15453 unsigned int val;
15454
15455 printf (" Tag_GNU_MIPS_ABI_FP: ");
15456 READ_ULEB (val, p, end);
15457 print_mips_fp_abi_value (val);
15458 return p;
15459 }
15460
15461 if (tag == Tag_GNU_MIPS_ABI_MSA)
15462 {
15463 unsigned int val;
15464
15465 printf (" Tag_GNU_MIPS_ABI_MSA: ");
15466 READ_ULEB (val, p, end);
15467
15468 switch (val)
15469 {
15470 case Val_GNU_MIPS_ABI_MSA_ANY:
15471 printf (_("Any MSA or not\n"));
15472 break;
15473 case Val_GNU_MIPS_ABI_MSA_128:
15474 printf (_("128-bit MSA\n"));
15475 break;
15476 default:
15477 printf ("??? (%d)\n", val);
15478 break;
15479 }
15480 return p;
15481 }
15482
15483 return display_tag_value (tag & 1, p, end);
15484 }
15485
15486 static unsigned char *
display_tic6x_attribute(unsigned char * p,const unsigned char * const end)15487 display_tic6x_attribute (unsigned char * p,
15488 const unsigned char * const end)
15489 {
15490 unsigned int tag;
15491 unsigned int val;
15492
15493 READ_ULEB (tag, p, end);
15494
15495 switch (tag)
15496 {
15497 case Tag_ISA:
15498 printf (" Tag_ISA: ");
15499 READ_ULEB (val, p, end);
15500
15501 switch (val)
15502 {
15503 case C6XABI_Tag_ISA_none:
15504 printf (_("None\n"));
15505 break;
15506 case C6XABI_Tag_ISA_C62X:
15507 printf ("C62x\n");
15508 break;
15509 case C6XABI_Tag_ISA_C67X:
15510 printf ("C67x\n");
15511 break;
15512 case C6XABI_Tag_ISA_C67XP:
15513 printf ("C67x+\n");
15514 break;
15515 case C6XABI_Tag_ISA_C64X:
15516 printf ("C64x\n");
15517 break;
15518 case C6XABI_Tag_ISA_C64XP:
15519 printf ("C64x+\n");
15520 break;
15521 case C6XABI_Tag_ISA_C674X:
15522 printf ("C674x\n");
15523 break;
15524 default:
15525 printf ("??? (%d)\n", val);
15526 break;
15527 }
15528 return p;
15529
15530 case Tag_ABI_wchar_t:
15531 printf (" Tag_ABI_wchar_t: ");
15532 READ_ULEB (val, p, end);
15533 switch (val)
15534 {
15535 case 0:
15536 printf (_("Not used\n"));
15537 break;
15538 case 1:
15539 printf (_("2 bytes\n"));
15540 break;
15541 case 2:
15542 printf (_("4 bytes\n"));
15543 break;
15544 default:
15545 printf ("??? (%d)\n", val);
15546 break;
15547 }
15548 return p;
15549
15550 case Tag_ABI_stack_align_needed:
15551 printf (" Tag_ABI_stack_align_needed: ");
15552 READ_ULEB (val, p, end);
15553 switch (val)
15554 {
15555 case 0:
15556 printf (_("8-byte\n"));
15557 break;
15558 case 1:
15559 printf (_("16-byte\n"));
15560 break;
15561 default:
15562 printf ("??? (%d)\n", val);
15563 break;
15564 }
15565 return p;
15566
15567 case Tag_ABI_stack_align_preserved:
15568 READ_ULEB (val, p, end);
15569 printf (" Tag_ABI_stack_align_preserved: ");
15570 switch (val)
15571 {
15572 case 0:
15573 printf (_("8-byte\n"));
15574 break;
15575 case 1:
15576 printf (_("16-byte\n"));
15577 break;
15578 default:
15579 printf ("??? (%d)\n", val);
15580 break;
15581 }
15582 return p;
15583
15584 case Tag_ABI_DSBT:
15585 READ_ULEB (val, p, end);
15586 printf (" Tag_ABI_DSBT: ");
15587 switch (val)
15588 {
15589 case 0:
15590 printf (_("DSBT addressing not used\n"));
15591 break;
15592 case 1:
15593 printf (_("DSBT addressing used\n"));
15594 break;
15595 default:
15596 printf ("??? (%d)\n", val);
15597 break;
15598 }
15599 return p;
15600
15601 case Tag_ABI_PID:
15602 READ_ULEB (val, p, end);
15603 printf (" Tag_ABI_PID: ");
15604 switch (val)
15605 {
15606 case 0:
15607 printf (_("Data addressing position-dependent\n"));
15608 break;
15609 case 1:
15610 printf (_("Data addressing position-independent, GOT near DP\n"));
15611 break;
15612 case 2:
15613 printf (_("Data addressing position-independent, GOT far from DP\n"));
15614 break;
15615 default:
15616 printf ("??? (%d)\n", val);
15617 break;
15618 }
15619 return p;
15620
15621 case Tag_ABI_PIC:
15622 READ_ULEB (val, p, end);
15623 printf (" Tag_ABI_PIC: ");
15624 switch (val)
15625 {
15626 case 0:
15627 printf (_("Code addressing position-dependent\n"));
15628 break;
15629 case 1:
15630 printf (_("Code addressing position-independent\n"));
15631 break;
15632 default:
15633 printf ("??? (%d)\n", val);
15634 break;
15635 }
15636 return p;
15637
15638 case Tag_ABI_array_object_alignment:
15639 READ_ULEB (val, p, end);
15640 printf (" Tag_ABI_array_object_alignment: ");
15641 switch (val)
15642 {
15643 case 0:
15644 printf (_("8-byte\n"));
15645 break;
15646 case 1:
15647 printf (_("4-byte\n"));
15648 break;
15649 case 2:
15650 printf (_("16-byte\n"));
15651 break;
15652 default:
15653 printf ("??? (%d)\n", val);
15654 break;
15655 }
15656 return p;
15657
15658 case Tag_ABI_array_object_align_expected:
15659 READ_ULEB (val, p, end);
15660 printf (" Tag_ABI_array_object_align_expected: ");
15661 switch (val)
15662 {
15663 case 0:
15664 printf (_("8-byte\n"));
15665 break;
15666 case 1:
15667 printf (_("4-byte\n"));
15668 break;
15669 case 2:
15670 printf (_("16-byte\n"));
15671 break;
15672 default:
15673 printf ("??? (%d)\n", val);
15674 break;
15675 }
15676 return p;
15677
15678 case Tag_ABI_compatibility:
15679 {
15680 READ_ULEB (val, p, end);
15681 printf (" Tag_ABI_compatibility: ");
15682 printf (_("flag = %d, vendor = "), val);
15683 if (p < end - 1)
15684 {
15685 size_t maxlen = (end - p) - 1;
15686
15687 print_symbol ((int) maxlen, (const char *) p);
15688 p += strnlen ((char *) p, maxlen) + 1;
15689 }
15690 else
15691 {
15692 printf (_("<corrupt>"));
15693 p = (unsigned char *) end;
15694 }
15695 putchar ('\n');
15696 return p;
15697 }
15698
15699 case Tag_ABI_conformance:
15700 {
15701 printf (" Tag_ABI_conformance: \"");
15702 if (p < end - 1)
15703 {
15704 size_t maxlen = (end - p) - 1;
15705
15706 print_symbol ((int) maxlen, (const char *) p);
15707 p += strnlen ((char *) p, maxlen) + 1;
15708 }
15709 else
15710 {
15711 printf (_("<corrupt>"));
15712 p = (unsigned char *) end;
15713 }
15714 printf ("\"\n");
15715 return p;
15716 }
15717 }
15718
15719 return display_tag_value (tag, p, end);
15720 }
15721
15722 static void
display_raw_attribute(unsigned char * p,unsigned char const * const end)15723 display_raw_attribute (unsigned char * p, unsigned char const * const end)
15724 {
15725 unsigned long addr = 0;
15726 size_t bytes = end - p;
15727
15728 assert (end >= p);
15729 while (bytes)
15730 {
15731 int j;
15732 int k;
15733 int lbytes = (bytes > 16 ? 16 : bytes);
15734
15735 printf (" 0x%8.8lx ", addr);
15736
15737 for (j = 0; j < 16; j++)
15738 {
15739 if (j < lbytes)
15740 printf ("%2.2x", p[j]);
15741 else
15742 printf (" ");
15743
15744 if ((j & 3) == 3)
15745 printf (" ");
15746 }
15747
15748 for (j = 0; j < lbytes; j++)
15749 {
15750 k = p[j];
15751 if (k >= ' ' && k < 0x7f)
15752 printf ("%c", k);
15753 else
15754 printf (".");
15755 }
15756
15757 putchar ('\n');
15758
15759 p += lbytes;
15760 bytes -= lbytes;
15761 addr += lbytes;
15762 }
15763
15764 putchar ('\n');
15765 }
15766
15767 static unsigned char *
display_msp430x_attribute(unsigned char * p,const unsigned char * const end)15768 display_msp430x_attribute (unsigned char * p,
15769 const unsigned char * const end)
15770 {
15771 unsigned int val;
15772 unsigned int tag;
15773
15774 READ_ULEB (tag, p, end);
15775
15776 switch (tag)
15777 {
15778 case OFBA_MSPABI_Tag_ISA:
15779 printf (" Tag_ISA: ");
15780 READ_ULEB (val, p, end);
15781 switch (val)
15782 {
15783 case 0: printf (_("None\n")); break;
15784 case 1: printf (_("MSP430\n")); break;
15785 case 2: printf (_("MSP430X\n")); break;
15786 default: printf ("??? (%d)\n", val); break;
15787 }
15788 break;
15789
15790 case OFBA_MSPABI_Tag_Code_Model:
15791 printf (" Tag_Code_Model: ");
15792 READ_ULEB (val, p, end);
15793 switch (val)
15794 {
15795 case 0: printf (_("None\n")); break;
15796 case 1: printf (_("Small\n")); break;
15797 case 2: printf (_("Large\n")); break;
15798 default: printf ("??? (%d)\n", val); break;
15799 }
15800 break;
15801
15802 case OFBA_MSPABI_Tag_Data_Model:
15803 printf (" Tag_Data_Model: ");
15804 READ_ULEB (val, p, end);
15805 switch (val)
15806 {
15807 case 0: printf (_("None\n")); break;
15808 case 1: printf (_("Small\n")); break;
15809 case 2: printf (_("Large\n")); break;
15810 case 3: printf (_("Restricted Large\n")); break;
15811 default: printf ("??? (%d)\n", val); break;
15812 }
15813 break;
15814
15815 default:
15816 printf (_(" <unknown tag %d>: "), tag);
15817
15818 if (tag & 1)
15819 {
15820 putchar ('"');
15821 if (p < end - 1)
15822 {
15823 size_t maxlen = (end - p) - 1;
15824
15825 print_symbol ((int) maxlen, (const char *) p);
15826 p += strnlen ((char *) p, maxlen) + 1;
15827 }
15828 else
15829 {
15830 printf (_("<corrupt>"));
15831 p = (unsigned char *) end;
15832 }
15833 printf ("\"\n");
15834 }
15835 else
15836 {
15837 READ_ULEB (val, p, end);
15838 printf ("%d (0x%x)\n", val, val);
15839 }
15840 break;
15841 }
15842
15843 assert (p <= end);
15844 return p;
15845 }
15846
15847 static unsigned char *
display_msp430_gnu_attribute(unsigned char * p,unsigned int tag,const unsigned char * const end)15848 display_msp430_gnu_attribute (unsigned char * p,
15849 unsigned int tag,
15850 const unsigned char * const end)
15851 {
15852 if (tag == Tag_GNU_MSP430_Data_Region)
15853 {
15854 unsigned int val;
15855
15856 printf (" Tag_GNU_MSP430_Data_Region: ");
15857 READ_ULEB (val, p, end);
15858
15859 switch (val)
15860 {
15861 case Val_GNU_MSP430_Data_Region_Any:
15862 printf (_("Any Region\n"));
15863 break;
15864 case Val_GNU_MSP430_Data_Region_Lower:
15865 printf (_("Lower Region Only\n"));
15866 break;
15867 default:
15868 printf ("??? (%u)\n", val);
15869 }
15870 return p;
15871 }
15872 return display_tag_value (tag & 1, p, end);
15873 }
15874
15875 struct riscv_attr_tag_t {
15876 const char *name;
15877 unsigned int tag;
15878 };
15879
15880 static struct riscv_attr_tag_t riscv_attr_tag[] =
15881 {
15882 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
15883 T(arch),
15884 T(priv_spec),
15885 T(priv_spec_minor),
15886 T(priv_spec_revision),
15887 T(unaligned_access),
15888 T(stack_align),
15889 #undef T
15890 };
15891
15892 static unsigned char *
display_riscv_attribute(unsigned char * p,const unsigned char * const end)15893 display_riscv_attribute (unsigned char *p,
15894 const unsigned char * const end)
15895 {
15896 unsigned int val;
15897 unsigned int tag;
15898 struct riscv_attr_tag_t *attr = NULL;
15899 unsigned i;
15900
15901 READ_ULEB (tag, p, end);
15902
15903 /* Find the name of attribute. */
15904 for (i = 0; i < ARRAY_SIZE (riscv_attr_tag); i++)
15905 {
15906 if (riscv_attr_tag[i].tag == tag)
15907 {
15908 attr = &riscv_attr_tag[i];
15909 break;
15910 }
15911 }
15912
15913 if (attr)
15914 printf (" %s: ", attr->name);
15915 else
15916 return display_tag_value (tag, p, end);
15917
15918 switch (tag)
15919 {
15920 case Tag_RISCV_priv_spec:
15921 case Tag_RISCV_priv_spec_minor:
15922 case Tag_RISCV_priv_spec_revision:
15923 READ_ULEB (val, p, end);
15924 printf (_("%u\n"), val);
15925 break;
15926 case Tag_RISCV_unaligned_access:
15927 READ_ULEB (val, p, end);
15928 switch (val)
15929 {
15930 case 0:
15931 printf (_("No unaligned access\n"));
15932 break;
15933 case 1:
15934 printf (_("Unaligned access\n"));
15935 break;
15936 }
15937 break;
15938 case Tag_RISCV_stack_align:
15939 READ_ULEB (val, p, end);
15940 printf (_("%u-bytes\n"), val);
15941 break;
15942 case Tag_RISCV_arch:
15943 p = display_tag_value (-1, p, end);
15944 break;
15945 default:
15946 return display_tag_value (tag, p, end);
15947 }
15948
15949 return p;
15950 }
15951
15952 static bfd_boolean
process_attributes(Filedata * filedata,const char * public_name,unsigned int proc_type,unsigned char * (* display_pub_attribute)(unsigned char *,const unsigned char * const),unsigned char * (* display_proc_gnu_attribute)(unsigned char *,unsigned int,const unsigned char * const))15953 process_attributes (Filedata * filedata,
15954 const char * public_name,
15955 unsigned int proc_type,
15956 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
15957 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
15958 {
15959 Elf_Internal_Shdr * sect;
15960 unsigned i;
15961 bfd_boolean res = TRUE;
15962
15963 /* Find the section header so that we get the size. */
15964 for (i = 0, sect = filedata->section_headers;
15965 i < filedata->file_header.e_shnum;
15966 i++, sect++)
15967 {
15968 unsigned char * contents;
15969 unsigned char * p;
15970
15971 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
15972 continue;
15973
15974 contents = (unsigned char *) get_data (NULL, filedata, sect->sh_offset, 1,
15975 sect->sh_size, _("attributes"));
15976 if (contents == NULL)
15977 {
15978 res = FALSE;
15979 continue;
15980 }
15981
15982 p = contents;
15983 /* The first character is the version of the attributes.
15984 Currently only version 1, (aka 'A') is recognised here. */
15985 if (*p != 'A')
15986 {
15987 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
15988 res = FALSE;
15989 }
15990 else
15991 {
15992 bfd_vma section_len;
15993
15994 section_len = sect->sh_size - 1;
15995 p++;
15996
15997 while (section_len > 0)
15998 {
15999 bfd_vma attr_len;
16000 unsigned int namelen;
16001 bfd_boolean public_section;
16002 bfd_boolean gnu_section;
16003
16004 if (section_len <= 4)
16005 {
16006 error (_("Tag section ends prematurely\n"));
16007 res = FALSE;
16008 break;
16009 }
16010 attr_len = byte_get (p, 4);
16011 p += 4;
16012
16013 if (attr_len > section_len)
16014 {
16015 error (_("Bad attribute length (%u > %u)\n"),
16016 (unsigned) attr_len, (unsigned) section_len);
16017 attr_len = section_len;
16018 res = FALSE;
16019 }
16020 /* PR 17531: file: 001-101425-0.004 */
16021 else if (attr_len < 5)
16022 {
16023 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
16024 res = FALSE;
16025 break;
16026 }
16027
16028 section_len -= attr_len;
16029 attr_len -= 4;
16030
16031 namelen = strnlen ((char *) p, attr_len) + 1;
16032 if (namelen == 0 || namelen >= attr_len)
16033 {
16034 error (_("Corrupt attribute section name\n"));
16035 res = FALSE;
16036 break;
16037 }
16038
16039 printf (_("Attribute Section: "));
16040 print_symbol (INT_MAX, (const char *) p);
16041 putchar ('\n');
16042
16043 if (public_name && streq ((char *) p, public_name))
16044 public_section = TRUE;
16045 else
16046 public_section = FALSE;
16047
16048 if (streq ((char *) p, "gnu"))
16049 gnu_section = TRUE;
16050 else
16051 gnu_section = FALSE;
16052
16053 p += namelen;
16054 attr_len -= namelen;
16055
16056 while (attr_len > 0 && p < contents + sect->sh_size)
16057 {
16058 int tag;
16059 unsigned int val;
16060 bfd_vma size;
16061 unsigned char * end;
16062
16063 /* PR binutils/17531: Safe handling of corrupt files. */
16064 if (attr_len < 6)
16065 {
16066 error (_("Unused bytes at end of section\n"));
16067 res = FALSE;
16068 section_len = 0;
16069 break;
16070 }
16071
16072 tag = *(p++);
16073 size = byte_get (p, 4);
16074 if (size > attr_len)
16075 {
16076 error (_("Bad subsection length (%u > %u)\n"),
16077 (unsigned) size, (unsigned) attr_len);
16078 res = FALSE;
16079 size = attr_len;
16080 }
16081 /* PR binutils/17531: Safe handling of corrupt files. */
16082 if (size < 6)
16083 {
16084 error (_("Bad subsection length (%u < 6)\n"),
16085 (unsigned) size);
16086 res = FALSE;
16087 section_len = 0;
16088 break;
16089 }
16090
16091 attr_len -= size;
16092 end = p + size - 1;
16093 assert (end <= contents + sect->sh_size);
16094 p += 4;
16095
16096 switch (tag)
16097 {
16098 case 1:
16099 printf (_("File Attributes\n"));
16100 break;
16101 case 2:
16102 printf (_("Section Attributes:"));
16103 goto do_numlist;
16104 case 3:
16105 printf (_("Symbol Attributes:"));
16106 /* Fall through. */
16107 do_numlist:
16108 for (;;)
16109 {
16110 READ_ULEB (val, p, end);
16111 if (val == 0)
16112 break;
16113 printf (" %d", val);
16114 }
16115 printf ("\n");
16116 break;
16117 default:
16118 printf (_("Unknown tag: %d\n"), tag);
16119 public_section = FALSE;
16120 break;
16121 }
16122
16123 if (public_section && display_pub_attribute != NULL)
16124 {
16125 while (p < end)
16126 p = display_pub_attribute (p, end);
16127 assert (p == end);
16128 }
16129 else if (gnu_section && display_proc_gnu_attribute != NULL)
16130 {
16131 while (p < end)
16132 p = display_gnu_attribute (p,
16133 display_proc_gnu_attribute,
16134 end);
16135 assert (p == end);
16136 }
16137 else if (p < end)
16138 {
16139 printf (_(" Unknown attribute:\n"));
16140 display_raw_attribute (p, end);
16141 p = end;
16142 }
16143 else
16144 attr_len = 0;
16145 }
16146 }
16147 }
16148
16149 free (contents);
16150 }
16151
16152 return res;
16153 }
16154
16155 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
16156 Print the Address, Access and Initial fields of an entry at VMA ADDR
16157 and return the VMA of the next entry, or -1 if there was a problem.
16158 Does not read from DATA_END or beyond. */
16159
16160 static bfd_vma
print_mips_got_entry(unsigned char * data,bfd_vma pltgot,bfd_vma addr,unsigned char * data_end)16161 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
16162 unsigned char * data_end)
16163 {
16164 printf (" ");
16165 print_vma (addr, LONG_HEX);
16166 printf (" ");
16167 if (addr < pltgot + 0xfff0)
16168 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
16169 else
16170 printf ("%10s", "");
16171 printf (" ");
16172 if (data == NULL)
16173 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
16174 else
16175 {
16176 bfd_vma entry;
16177 unsigned char * from = data + addr - pltgot;
16178
16179 if (from + (is_32bit_elf ? 4 : 8) > data_end)
16180 {
16181 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
16182 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
16183 return (bfd_vma) -1;
16184 }
16185 else
16186 {
16187 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
16188 print_vma (entry, LONG_HEX);
16189 }
16190 }
16191 return addr + (is_32bit_elf ? 4 : 8);
16192 }
16193
16194 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
16195 PLTGOT. Print the Address and Initial fields of an entry at VMA
16196 ADDR and return the VMA of the next entry. */
16197
16198 static bfd_vma
print_mips_pltgot_entry(unsigned char * data,bfd_vma pltgot,bfd_vma addr)16199 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
16200 {
16201 printf (" ");
16202 print_vma (addr, LONG_HEX);
16203 printf (" ");
16204 if (data == NULL)
16205 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
16206 else
16207 {
16208 bfd_vma entry;
16209
16210 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
16211 print_vma (entry, LONG_HEX);
16212 }
16213 return addr + (is_32bit_elf ? 4 : 8);
16214 }
16215
16216 static void
print_mips_ases(unsigned int mask)16217 print_mips_ases (unsigned int mask)
16218 {
16219 if (mask & AFL_ASE_DSP)
16220 fputs ("\n\tDSP ASE", stdout);
16221 if (mask & AFL_ASE_DSPR2)
16222 fputs ("\n\tDSP R2 ASE", stdout);
16223 if (mask & AFL_ASE_DSPR3)
16224 fputs ("\n\tDSP R3 ASE", stdout);
16225 if (mask & AFL_ASE_EVA)
16226 fputs ("\n\tEnhanced VA Scheme", stdout);
16227 if (mask & AFL_ASE_MCU)
16228 fputs ("\n\tMCU (MicroController) ASE", stdout);
16229 if (mask & AFL_ASE_MDMX)
16230 fputs ("\n\tMDMX ASE", stdout);
16231 if (mask & AFL_ASE_MIPS3D)
16232 fputs ("\n\tMIPS-3D ASE", stdout);
16233 if (mask & AFL_ASE_MT)
16234 fputs ("\n\tMT ASE", stdout);
16235 if (mask & AFL_ASE_SMARTMIPS)
16236 fputs ("\n\tSmartMIPS ASE", stdout);
16237 if (mask & AFL_ASE_VIRT)
16238 fputs ("\n\tVZ ASE", stdout);
16239 if (mask & AFL_ASE_MSA)
16240 fputs ("\n\tMSA ASE", stdout);
16241 if (mask & AFL_ASE_MIPS16)
16242 fputs ("\n\tMIPS16 ASE", stdout);
16243 if (mask & AFL_ASE_MICROMIPS)
16244 fputs ("\n\tMICROMIPS ASE", stdout);
16245 if (mask & AFL_ASE_XPA)
16246 fputs ("\n\tXPA ASE", stdout);
16247 if (mask & AFL_ASE_MIPS16E2)
16248 fputs ("\n\tMIPS16e2 ASE", stdout);
16249 if (mask & AFL_ASE_CRC)
16250 fputs ("\n\tCRC ASE", stdout);
16251 if (mask & AFL_ASE_GINV)
16252 fputs ("\n\tGINV ASE", stdout);
16253 if (mask & AFL_ASE_LOONGSON_MMI)
16254 fputs ("\n\tLoongson MMI ASE", stdout);
16255 if (mask & AFL_ASE_LOONGSON_CAM)
16256 fputs ("\n\tLoongson CAM ASE", stdout);
16257 if (mask & AFL_ASE_LOONGSON_EXT)
16258 fputs ("\n\tLoongson EXT ASE", stdout);
16259 if (mask & AFL_ASE_LOONGSON_EXT2)
16260 fputs ("\n\tLoongson EXT2 ASE", stdout);
16261 if (mask == 0)
16262 fprintf (stdout, "\n\t%s", _("None"));
16263 else if ((mask & ~AFL_ASE_MASK) != 0)
16264 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
16265 }
16266
16267 static void
print_mips_isa_ext(unsigned int isa_ext)16268 print_mips_isa_ext (unsigned int isa_ext)
16269 {
16270 switch (isa_ext)
16271 {
16272 case 0:
16273 fputs (_("None"), stdout);
16274 break;
16275 case AFL_EXT_XLR:
16276 fputs ("RMI XLR", stdout);
16277 break;
16278 case AFL_EXT_OCTEON3:
16279 fputs ("Cavium Networks Octeon3", stdout);
16280 break;
16281 case AFL_EXT_OCTEON2:
16282 fputs ("Cavium Networks Octeon2", stdout);
16283 break;
16284 case AFL_EXT_OCTEONP:
16285 fputs ("Cavium Networks OcteonP", stdout);
16286 break;
16287 case AFL_EXT_OCTEON:
16288 fputs ("Cavium Networks Octeon", stdout);
16289 break;
16290 case AFL_EXT_5900:
16291 fputs ("Toshiba R5900", stdout);
16292 break;
16293 case AFL_EXT_4650:
16294 fputs ("MIPS R4650", stdout);
16295 break;
16296 case AFL_EXT_4010:
16297 fputs ("LSI R4010", stdout);
16298 break;
16299 case AFL_EXT_4100:
16300 fputs ("NEC VR4100", stdout);
16301 break;
16302 case AFL_EXT_3900:
16303 fputs ("Toshiba R3900", stdout);
16304 break;
16305 case AFL_EXT_10000:
16306 fputs ("MIPS R10000", stdout);
16307 break;
16308 case AFL_EXT_SB1:
16309 fputs ("Broadcom SB-1", stdout);
16310 break;
16311 case AFL_EXT_4111:
16312 fputs ("NEC VR4111/VR4181", stdout);
16313 break;
16314 case AFL_EXT_4120:
16315 fputs ("NEC VR4120", stdout);
16316 break;
16317 case AFL_EXT_5400:
16318 fputs ("NEC VR5400", stdout);
16319 break;
16320 case AFL_EXT_5500:
16321 fputs ("NEC VR5500", stdout);
16322 break;
16323 case AFL_EXT_LOONGSON_2E:
16324 fputs ("ST Microelectronics Loongson 2E", stdout);
16325 break;
16326 case AFL_EXT_LOONGSON_2F:
16327 fputs ("ST Microelectronics Loongson 2F", stdout);
16328 break;
16329 case AFL_EXT_INTERAPTIV_MR2:
16330 fputs ("Imagination interAptiv MR2", stdout);
16331 break;
16332 default:
16333 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
16334 }
16335 }
16336
16337 static signed int
get_mips_reg_size(int reg_size)16338 get_mips_reg_size (int reg_size)
16339 {
16340 return (reg_size == AFL_REG_NONE) ? 0
16341 : (reg_size == AFL_REG_32) ? 32
16342 : (reg_size == AFL_REG_64) ? 64
16343 : (reg_size == AFL_REG_128) ? 128
16344 : -1;
16345 }
16346
16347 static bfd_boolean
process_mips_specific(Filedata * filedata)16348 process_mips_specific (Filedata * filedata)
16349 {
16350 Elf_Internal_Dyn * entry;
16351 Elf_Internal_Shdr *sect = NULL;
16352 size_t liblist_offset = 0;
16353 size_t liblistno = 0;
16354 size_t conflictsno = 0;
16355 size_t options_offset = 0;
16356 size_t conflicts_offset = 0;
16357 size_t pltrelsz = 0;
16358 size_t pltrel = 0;
16359 bfd_vma pltgot = 0;
16360 bfd_vma mips_pltgot = 0;
16361 bfd_vma jmprel = 0;
16362 bfd_vma local_gotno = 0;
16363 bfd_vma gotsym = 0;
16364 bfd_vma symtabno = 0;
16365 bfd_boolean res = TRUE;
16366
16367 if (! process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
16368 display_mips_gnu_attribute))
16369 res = FALSE;
16370
16371 sect = find_section (filedata, ".MIPS.abiflags");
16372
16373 if (sect != NULL)
16374 {
16375 Elf_External_ABIFlags_v0 *abiflags_ext;
16376 Elf_Internal_ABIFlags_v0 abiflags_in;
16377
16378 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
16379 {
16380 error (_("Corrupt MIPS ABI Flags section.\n"));
16381 res = FALSE;
16382 }
16383 else
16384 {
16385 abiflags_ext = get_data (NULL, filedata, sect->sh_offset, 1,
16386 sect->sh_size, _("MIPS ABI Flags section"));
16387 if (abiflags_ext)
16388 {
16389 abiflags_in.version = BYTE_GET (abiflags_ext->version);
16390 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
16391 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
16392 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
16393 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
16394 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
16395 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
16396 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
16397 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
16398 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
16399 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
16400
16401 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
16402 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
16403 if (abiflags_in.isa_rev > 1)
16404 printf ("r%d", abiflags_in.isa_rev);
16405 printf ("\nGPR size: %d",
16406 get_mips_reg_size (abiflags_in.gpr_size));
16407 printf ("\nCPR1 size: %d",
16408 get_mips_reg_size (abiflags_in.cpr1_size));
16409 printf ("\nCPR2 size: %d",
16410 get_mips_reg_size (abiflags_in.cpr2_size));
16411 fputs ("\nFP ABI: ", stdout);
16412 print_mips_fp_abi_value (abiflags_in.fp_abi);
16413 fputs ("ISA Extension: ", stdout);
16414 print_mips_isa_ext (abiflags_in.isa_ext);
16415 fputs ("\nASEs:", stdout);
16416 print_mips_ases (abiflags_in.ases);
16417 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
16418 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
16419 fputc ('\n', stdout);
16420 free (abiflags_ext);
16421 }
16422 }
16423 }
16424
16425 /* We have a lot of special sections. Thanks SGI! */
16426 if (dynamic_section == NULL)
16427 {
16428 /* No dynamic information available. See if there is static GOT. */
16429 sect = find_section (filedata, ".got");
16430 if (sect != NULL)
16431 {
16432 unsigned char *data_end;
16433 unsigned char *data;
16434 bfd_vma ent, end;
16435 int addr_size;
16436
16437 pltgot = sect->sh_addr;
16438
16439 ent = pltgot;
16440 addr_size = (is_32bit_elf ? 4 : 8);
16441 end = pltgot + sect->sh_size;
16442
16443 data = (unsigned char *) get_data (NULL, filedata, sect->sh_offset,
16444 end - pltgot, 1,
16445 _("Global Offset Table data"));
16446 /* PR 12855: Null data is handled gracefully throughout. */
16447 data_end = data + (end - pltgot);
16448
16449 printf (_("\nStatic GOT:\n"));
16450 printf (_(" Canonical gp value: "));
16451 print_vma (ent + 0x7ff0, LONG_HEX);
16452 printf ("\n\n");
16453
16454 /* In a dynamic binary GOT[0] is reserved for the dynamic
16455 loader to store the lazy resolver pointer, however in
16456 a static binary it may well have been omitted and GOT
16457 reduced to a table of addresses.
16458 PR 21344: Check for the entry being fully available
16459 before fetching it. */
16460 if (data
16461 && data + ent - pltgot + addr_size <= data_end
16462 && byte_get (data + ent - pltgot, addr_size) == 0)
16463 {
16464 printf (_(" Reserved entries:\n"));
16465 printf (_(" %*s %10s %*s\n"),
16466 addr_size * 2, _("Address"), _("Access"),
16467 addr_size * 2, _("Value"));
16468 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16469 printf ("\n");
16470 if (ent == (bfd_vma) -1)
16471 goto sgot_print_fail;
16472
16473 /* Check for the MSB of GOT[1] being set, identifying a
16474 GNU object. This entry will be used by some runtime
16475 loaders, to store the module pointer. Otherwise this
16476 is an ordinary local entry.
16477 PR 21344: Check for the entry being fully available
16478 before fetching it. */
16479 if (data
16480 && data + ent - pltgot + addr_size <= data_end
16481 && (byte_get (data + ent - pltgot, addr_size)
16482 >> (addr_size * 8 - 1)) != 0)
16483 {
16484 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16485 printf ("\n");
16486 if (ent == (bfd_vma) -1)
16487 goto sgot_print_fail;
16488 }
16489 printf ("\n");
16490 }
16491
16492 if (data != NULL && ent < end)
16493 {
16494 printf (_(" Local entries:\n"));
16495 printf (" %*s %10s %*s\n",
16496 addr_size * 2, _("Address"), _("Access"),
16497 addr_size * 2, _("Value"));
16498 while (ent < end)
16499 {
16500 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16501 printf ("\n");
16502 if (ent == (bfd_vma) -1)
16503 goto sgot_print_fail;
16504 }
16505 printf ("\n");
16506 }
16507
16508 sgot_print_fail:
16509 if (data)
16510 free (data);
16511 }
16512 return res;
16513 }
16514
16515 for (entry = dynamic_section;
16516 /* PR 17531 file: 012-50589-0.004. */
16517 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
16518 ++entry)
16519 switch (entry->d_tag)
16520 {
16521 case DT_MIPS_LIBLIST:
16522 liblist_offset
16523 = offset_from_vma (filedata, entry->d_un.d_val,
16524 liblistno * sizeof (Elf32_External_Lib));
16525 break;
16526 case DT_MIPS_LIBLISTNO:
16527 liblistno = entry->d_un.d_val;
16528 break;
16529 case DT_MIPS_OPTIONS:
16530 options_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
16531 break;
16532 case DT_MIPS_CONFLICT:
16533 conflicts_offset
16534 = offset_from_vma (filedata, entry->d_un.d_val,
16535 conflictsno * sizeof (Elf32_External_Conflict));
16536 break;
16537 case DT_MIPS_CONFLICTNO:
16538 conflictsno = entry->d_un.d_val;
16539 break;
16540 case DT_PLTGOT:
16541 pltgot = entry->d_un.d_ptr;
16542 break;
16543 case DT_MIPS_LOCAL_GOTNO:
16544 local_gotno = entry->d_un.d_val;
16545 break;
16546 case DT_MIPS_GOTSYM:
16547 gotsym = entry->d_un.d_val;
16548 break;
16549 case DT_MIPS_SYMTABNO:
16550 symtabno = entry->d_un.d_val;
16551 break;
16552 case DT_MIPS_PLTGOT:
16553 mips_pltgot = entry->d_un.d_ptr;
16554 break;
16555 case DT_PLTREL:
16556 pltrel = entry->d_un.d_val;
16557 break;
16558 case DT_PLTRELSZ:
16559 pltrelsz = entry->d_un.d_val;
16560 break;
16561 case DT_JMPREL:
16562 jmprel = entry->d_un.d_ptr;
16563 break;
16564 default:
16565 break;
16566 }
16567
16568 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
16569 {
16570 Elf32_External_Lib * elib;
16571 size_t cnt;
16572
16573 elib = (Elf32_External_Lib *) get_data (NULL, filedata, liblist_offset,
16574 liblistno,
16575 sizeof (Elf32_External_Lib),
16576 _("liblist section data"));
16577 if (elib)
16578 {
16579 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16580 "\nSection '.liblist' contains %lu entries:\n",
16581 (unsigned long) liblistno),
16582 (unsigned long) liblistno);
16583 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
16584 stdout);
16585
16586 for (cnt = 0; cnt < liblistno; ++cnt)
16587 {
16588 Elf32_Lib liblist;
16589 time_t atime;
16590 char timebuf[128];
16591 struct tm * tmp;
16592
16593 liblist.l_name = BYTE_GET (elib[cnt].l_name);
16594 atime = BYTE_GET (elib[cnt].l_time_stamp);
16595 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16596 liblist.l_version = BYTE_GET (elib[cnt].l_version);
16597 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16598
16599 tmp = gmtime (&atime);
16600 snprintf (timebuf, sizeof (timebuf),
16601 "%04u-%02u-%02uT%02u:%02u:%02u",
16602 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16603 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16604
16605 printf ("%3lu: ", (unsigned long) cnt);
16606 if (VALID_DYNAMIC_NAME (liblist.l_name))
16607 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
16608 else
16609 printf (_("<corrupt: %9ld>"), liblist.l_name);
16610 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
16611 liblist.l_version);
16612
16613 if (liblist.l_flags == 0)
16614 puts (_(" NONE"));
16615 else
16616 {
16617 static const struct
16618 {
16619 const char * name;
16620 int bit;
16621 }
16622 l_flags_vals[] =
16623 {
16624 { " EXACT_MATCH", LL_EXACT_MATCH },
16625 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
16626 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
16627 { " EXPORTS", LL_EXPORTS },
16628 { " DELAY_LOAD", LL_DELAY_LOAD },
16629 { " DELTA", LL_DELTA }
16630 };
16631 int flags = liblist.l_flags;
16632 size_t fcnt;
16633
16634 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
16635 if ((flags & l_flags_vals[fcnt].bit) != 0)
16636 {
16637 fputs (l_flags_vals[fcnt].name, stdout);
16638 flags ^= l_flags_vals[fcnt].bit;
16639 }
16640 if (flags != 0)
16641 printf (" %#x", (unsigned int) flags);
16642
16643 puts ("");
16644 }
16645 }
16646
16647 free (elib);
16648 }
16649 else
16650 res = FALSE;
16651 }
16652
16653 if (options_offset != 0)
16654 {
16655 Elf_External_Options * eopt;
16656 size_t offset;
16657 int cnt;
16658 sect = filedata->section_headers;
16659
16660 /* Find the section header so that we get the size. */
16661 sect = find_section_by_type (filedata, SHT_MIPS_OPTIONS);
16662 /* PR 17533 file: 012-277276-0.004. */
16663 if (sect == NULL)
16664 {
16665 error (_("No MIPS_OPTIONS header found\n"));
16666 return FALSE;
16667 }
16668 /* PR 24243 */
16669 if (sect->sh_size < sizeof (* eopt))
16670 {
16671 error (_("The MIPS options section is too small.\n"));
16672 return FALSE;
16673 }
16674
16675 eopt = (Elf_External_Options *) get_data (NULL, filedata, options_offset, 1,
16676 sect->sh_size, _("options"));
16677 if (eopt)
16678 {
16679 Elf_Internal_Options * iopt;
16680 Elf_Internal_Options * option;
16681 Elf_Internal_Options * iopt_end;
16682
16683 iopt = (Elf_Internal_Options *)
16684 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
16685 if (iopt == NULL)
16686 {
16687 error (_("Out of memory allocating space for MIPS options\n"));
16688 return FALSE;
16689 }
16690
16691 offset = cnt = 0;
16692 option = iopt;
16693 iopt_end = iopt + (sect->sh_size / sizeof (eopt));
16694
16695 while (offset <= sect->sh_size - sizeof (* eopt))
16696 {
16697 Elf_External_Options * eoption;
16698
16699 eoption = (Elf_External_Options *) ((char *) eopt + offset);
16700
16701 option->kind = BYTE_GET (eoption->kind);
16702 option->size = BYTE_GET (eoption->size);
16703 option->section = BYTE_GET (eoption->section);
16704 option->info = BYTE_GET (eoption->info);
16705
16706 /* PR 17531: file: ffa0fa3b. */
16707 if (option->size < sizeof (* eopt)
16708 || offset + option->size > sect->sh_size)
16709 {
16710 error (_("Invalid size (%u) for MIPS option\n"), option->size);
16711 return FALSE;
16712 }
16713 offset += option->size;
16714
16715 ++option;
16716 ++cnt;
16717 }
16718
16719 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16720 "\nSection '%s' contains %d entries:\n",
16721 cnt),
16722 printable_section_name (filedata, sect), cnt);
16723
16724 option = iopt;
16725 offset = 0;
16726
16727 while (cnt-- > 0)
16728 {
16729 size_t len;
16730
16731 switch (option->kind)
16732 {
16733 case ODK_NULL:
16734 /* This shouldn't happen. */
16735 printf (" NULL %d %lx", option->section, option->info);
16736 break;
16737
16738 case ODK_REGINFO:
16739 printf (" REGINFO ");
16740 if (filedata->file_header.e_machine == EM_MIPS)
16741 {
16742 Elf32_External_RegInfo * ereg;
16743 Elf32_RegInfo reginfo;
16744
16745 /* 32bit form. */
16746 if (option + 2 > iopt_end)
16747 {
16748 printf (_("<corrupt>\n"));
16749 error (_("Truncated MIPS REGINFO option\n"));
16750 cnt = 0;
16751 break;
16752 }
16753
16754 ereg = (Elf32_External_RegInfo *) (option + 1);
16755
16756 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
16757 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16758 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16759 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16760 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16761 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
16762
16763 printf ("GPR %08lx GP 0x%lx\n",
16764 reginfo.ri_gprmask,
16765 (unsigned long) reginfo.ri_gp_value);
16766 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16767 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16768 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16769 }
16770 else
16771 {
16772 /* 64 bit form. */
16773 Elf64_External_RegInfo * ereg;
16774 Elf64_Internal_RegInfo reginfo;
16775
16776 if (option + 2 > iopt_end)
16777 {
16778 printf (_("<corrupt>\n"));
16779 error (_("Truncated MIPS REGINFO option\n"));
16780 cnt = 0;
16781 break;
16782 }
16783
16784 ereg = (Elf64_External_RegInfo *) (option + 1);
16785 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
16786 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16787 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16788 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16789 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16790 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
16791
16792 printf ("GPR %08lx GP 0x",
16793 reginfo.ri_gprmask);
16794 printf_vma (reginfo.ri_gp_value);
16795 printf ("\n");
16796
16797 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16798 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16799 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16800 }
16801 ++option;
16802 continue;
16803
16804 case ODK_EXCEPTIONS:
16805 fputs (" EXCEPTIONS fpe_min(", stdout);
16806 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
16807 fputs (") fpe_max(", stdout);
16808 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
16809 fputs (")", stdout);
16810
16811 if (option->info & OEX_PAGE0)
16812 fputs (" PAGE0", stdout);
16813 if (option->info & OEX_SMM)
16814 fputs (" SMM", stdout);
16815 if (option->info & OEX_FPDBUG)
16816 fputs (" FPDBUG", stdout);
16817 if (option->info & OEX_DISMISS)
16818 fputs (" DISMISS", stdout);
16819 break;
16820
16821 case ODK_PAD:
16822 fputs (" PAD ", stdout);
16823 if (option->info & OPAD_PREFIX)
16824 fputs (" PREFIX", stdout);
16825 if (option->info & OPAD_POSTFIX)
16826 fputs (" POSTFIX", stdout);
16827 if (option->info & OPAD_SYMBOL)
16828 fputs (" SYMBOL", stdout);
16829 break;
16830
16831 case ODK_HWPATCH:
16832 fputs (" HWPATCH ", stdout);
16833 if (option->info & OHW_R4KEOP)
16834 fputs (" R4KEOP", stdout);
16835 if (option->info & OHW_R8KPFETCH)
16836 fputs (" R8KPFETCH", stdout);
16837 if (option->info & OHW_R5KEOP)
16838 fputs (" R5KEOP", stdout);
16839 if (option->info & OHW_R5KCVTL)
16840 fputs (" R5KCVTL", stdout);
16841 break;
16842
16843 case ODK_FILL:
16844 fputs (" FILL ", stdout);
16845 /* XXX Print content of info word? */
16846 break;
16847
16848 case ODK_TAGS:
16849 fputs (" TAGS ", stdout);
16850 /* XXX Print content of info word? */
16851 break;
16852
16853 case ODK_HWAND:
16854 fputs (" HWAND ", stdout);
16855 if (option->info & OHWA0_R4KEOP_CHECKED)
16856 fputs (" R4KEOP_CHECKED", stdout);
16857 if (option->info & OHWA0_R4KEOP_CLEAN)
16858 fputs (" R4KEOP_CLEAN", stdout);
16859 break;
16860
16861 case ODK_HWOR:
16862 fputs (" HWOR ", stdout);
16863 if (option->info & OHWA0_R4KEOP_CHECKED)
16864 fputs (" R4KEOP_CHECKED", stdout);
16865 if (option->info & OHWA0_R4KEOP_CLEAN)
16866 fputs (" R4KEOP_CLEAN", stdout);
16867 break;
16868
16869 case ODK_GP_GROUP:
16870 printf (" GP_GROUP %#06lx self-contained %#06lx",
16871 option->info & OGP_GROUP,
16872 (option->info & OGP_SELF) >> 16);
16873 break;
16874
16875 case ODK_IDENT:
16876 printf (" IDENT %#06lx self-contained %#06lx",
16877 option->info & OGP_GROUP,
16878 (option->info & OGP_SELF) >> 16);
16879 break;
16880
16881 default:
16882 /* This shouldn't happen. */
16883 printf (" %3d ??? %d %lx",
16884 option->kind, option->section, option->info);
16885 break;
16886 }
16887
16888 len = sizeof (* eopt);
16889 while (len < option->size)
16890 {
16891 unsigned char datum = * ((unsigned char *) eopt + offset + len);
16892
16893 if (ISPRINT (datum))
16894 printf ("%c", datum);
16895 else
16896 printf ("\\%03o", datum);
16897 len ++;
16898 }
16899 fputs ("\n", stdout);
16900
16901 offset += option->size;
16902 ++option;
16903 }
16904
16905 free (eopt);
16906 }
16907 else
16908 res = FALSE;
16909 }
16910
16911 if (conflicts_offset != 0 && conflictsno != 0)
16912 {
16913 Elf32_Conflict * iconf;
16914 size_t cnt;
16915
16916 if (dynamic_symbols == NULL)
16917 {
16918 error (_("conflict list found without a dynamic symbol table\n"));
16919 return FALSE;
16920 }
16921
16922 /* PR 21345 - print a slightly more helpful error message
16923 if we are sure that the cmalloc will fail. */
16924 if (conflictsno * sizeof (* iconf) > filedata->file_size)
16925 {
16926 error (_("Overlarge number of conflicts detected: %lx\n"),
16927 (long) conflictsno);
16928 return FALSE;
16929 }
16930
16931 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
16932 if (iconf == NULL)
16933 {
16934 error (_("Out of memory allocating space for dynamic conflicts\n"));
16935 return FALSE;
16936 }
16937
16938 if (is_32bit_elf)
16939 {
16940 Elf32_External_Conflict * econf32;
16941
16942 econf32 = (Elf32_External_Conflict *)
16943 get_data (NULL, filedata, conflicts_offset, conflictsno,
16944 sizeof (* econf32), _("conflict"));
16945 if (!econf32)
16946 return FALSE;
16947
16948 for (cnt = 0; cnt < conflictsno; ++cnt)
16949 iconf[cnt] = BYTE_GET (econf32[cnt]);
16950
16951 free (econf32);
16952 }
16953 else
16954 {
16955 Elf64_External_Conflict * econf64;
16956
16957 econf64 = (Elf64_External_Conflict *)
16958 get_data (NULL, filedata, conflicts_offset, conflictsno,
16959 sizeof (* econf64), _("conflict"));
16960 if (!econf64)
16961 return FALSE;
16962
16963 for (cnt = 0; cnt < conflictsno; ++cnt)
16964 iconf[cnt] = BYTE_GET (econf64[cnt]);
16965
16966 free (econf64);
16967 }
16968
16969 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16970 "\nSection '.conflict' contains %lu entries:\n",
16971 (unsigned long) conflictsno),
16972 (unsigned long) conflictsno);
16973 puts (_(" Num: Index Value Name"));
16974
16975 for (cnt = 0; cnt < conflictsno; ++cnt)
16976 {
16977 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
16978
16979 if (iconf[cnt] >= num_dynamic_syms)
16980 printf (_("<corrupt symbol index>"));
16981 else
16982 {
16983 Elf_Internal_Sym * psym;
16984
16985 psym = & dynamic_symbols[iconf[cnt]];
16986 print_vma (psym->st_value, FULL_HEX);
16987 putchar (' ');
16988 if (VALID_DYNAMIC_NAME (psym->st_name))
16989 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
16990 else
16991 printf (_("<corrupt: %14ld>"), psym->st_name);
16992 }
16993 putchar ('\n');
16994 }
16995
16996 free (iconf);
16997 }
16998
16999 if (pltgot != 0 && local_gotno != 0)
17000 {
17001 bfd_vma ent, local_end, global_end;
17002 size_t i, offset;
17003 unsigned char * data;
17004 unsigned char * data_end;
17005 int addr_size;
17006
17007 ent = pltgot;
17008 addr_size = (is_32bit_elf ? 4 : 8);
17009 local_end = pltgot + local_gotno * addr_size;
17010
17011 /* PR binutils/17533 file: 012-111227-0.004 */
17012 if (symtabno < gotsym)
17013 {
17014 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
17015 (unsigned long) gotsym, (unsigned long) symtabno);
17016 return FALSE;
17017 }
17018
17019 global_end = local_end + (symtabno - gotsym) * addr_size;
17020 /* PR 17531: file: 54c91a34. */
17021 if (global_end < local_end)
17022 {
17023 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
17024 return FALSE;
17025 }
17026
17027 offset = offset_from_vma (filedata, pltgot, global_end - pltgot);
17028 data = (unsigned char *) get_data (NULL, filedata, offset,
17029 global_end - pltgot, 1,
17030 _("Global Offset Table data"));
17031 /* PR 12855: Null data is handled gracefully throughout. */
17032 data_end = data + (global_end - pltgot);
17033
17034 printf (_("\nPrimary GOT:\n"));
17035 printf (_(" Canonical gp value: "));
17036 print_vma (pltgot + 0x7ff0, LONG_HEX);
17037 printf ("\n\n");
17038
17039 printf (_(" Reserved entries:\n"));
17040 printf (_(" %*s %10s %*s Purpose\n"),
17041 addr_size * 2, _("Address"), _("Access"),
17042 addr_size * 2, _("Initial"));
17043 ent = print_mips_got_entry (data, pltgot, ent, data_end);
17044 printf (_(" Lazy resolver\n"));
17045 if (ent == (bfd_vma) -1)
17046 goto got_print_fail;
17047
17048 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
17049 This entry will be used by some runtime loaders, to store the
17050 module pointer. Otherwise this is an ordinary local entry.
17051 PR 21344: Check for the entry being fully available before
17052 fetching it. */
17053 if (data
17054 && data + ent - pltgot + addr_size <= data_end
17055 && (byte_get (data + ent - pltgot, addr_size)
17056 >> (addr_size * 8 - 1)) != 0)
17057 {
17058 ent = print_mips_got_entry (data, pltgot, ent, data_end);
17059 printf (_(" Module pointer (GNU extension)\n"));
17060 if (ent == (bfd_vma) -1)
17061 goto got_print_fail;
17062 }
17063 printf ("\n");
17064
17065 if (data != NULL && ent < local_end)
17066 {
17067 printf (_(" Local entries:\n"));
17068 printf (" %*s %10s %*s\n",
17069 addr_size * 2, _("Address"), _("Access"),
17070 addr_size * 2, _("Initial"));
17071 while (ent < local_end)
17072 {
17073 ent = print_mips_got_entry (data, pltgot, ent, data_end);
17074 printf ("\n");
17075 if (ent == (bfd_vma) -1)
17076 goto got_print_fail;
17077 }
17078 printf ("\n");
17079 }
17080
17081 if (data != NULL && gotsym < symtabno)
17082 {
17083 int sym_width;
17084
17085 printf (_(" Global entries:\n"));
17086 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
17087 addr_size * 2, _("Address"),
17088 _("Access"),
17089 addr_size * 2, _("Initial"),
17090 addr_size * 2, _("Sym.Val."),
17091 _("Type"),
17092 /* Note for translators: "Ndx" = abbreviated form of "Index". */
17093 _("Ndx"), _("Name"));
17094
17095 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
17096
17097 for (i = gotsym; i < symtabno; i++)
17098 {
17099 ent = print_mips_got_entry (data, pltgot, ent, data_end);
17100 printf (" ");
17101
17102 if (dynamic_symbols == NULL)
17103 printf (_("<no dynamic symbols>"));
17104 else if (i < num_dynamic_syms)
17105 {
17106 Elf_Internal_Sym * psym = dynamic_symbols + i;
17107
17108 print_vma (psym->st_value, LONG_HEX);
17109 printf (" %-7s %3s ",
17110 get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
17111 get_symbol_index_type (filedata, psym->st_shndx));
17112
17113 if (VALID_DYNAMIC_NAME (psym->st_name))
17114 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
17115 else
17116 printf (_("<corrupt: %14ld>"), psym->st_name);
17117 }
17118 else
17119 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
17120 (unsigned long) i);
17121
17122 printf ("\n");
17123 if (ent == (bfd_vma) -1)
17124 break;
17125 }
17126 printf ("\n");
17127 }
17128
17129 got_print_fail:
17130 if (data)
17131 free (data);
17132 }
17133
17134 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
17135 {
17136 bfd_vma ent, end;
17137 size_t offset, rel_offset;
17138 unsigned long count, i;
17139 unsigned char * data;
17140 int addr_size, sym_width;
17141 Elf_Internal_Rela * rels;
17142
17143 rel_offset = offset_from_vma (filedata, jmprel, pltrelsz);
17144 if (pltrel == DT_RELA)
17145 {
17146 if (!slurp_rela_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
17147 return FALSE;
17148 }
17149 else
17150 {
17151 if (!slurp_rel_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
17152 return FALSE;
17153 }
17154
17155 ent = mips_pltgot;
17156 addr_size = (is_32bit_elf ? 4 : 8);
17157 end = mips_pltgot + (2 + count) * addr_size;
17158
17159 offset = offset_from_vma (filedata, mips_pltgot, end - mips_pltgot);
17160 data = (unsigned char *) get_data (NULL, filedata, offset, end - mips_pltgot,
17161 1, _("Procedure Linkage Table data"));
17162 if (data == NULL)
17163 return FALSE;
17164
17165 printf ("\nPLT GOT:\n\n");
17166 printf (_(" Reserved entries:\n"));
17167 printf (_(" %*s %*s Purpose\n"),
17168 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
17169 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
17170 printf (_(" PLT lazy resolver\n"));
17171 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
17172 printf (_(" Module pointer\n"));
17173 printf ("\n");
17174
17175 printf (_(" Entries:\n"));
17176 printf (" %*s %*s %*s %-7s %3s %s\n",
17177 addr_size * 2, _("Address"),
17178 addr_size * 2, _("Initial"),
17179 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
17180 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
17181 for (i = 0; i < count; i++)
17182 {
17183 unsigned long idx = get_reloc_symindex (rels[i].r_info);
17184
17185 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
17186 printf (" ");
17187
17188 if (idx >= num_dynamic_syms)
17189 printf (_("<corrupt symbol index: %lu>"), idx);
17190 else
17191 {
17192 Elf_Internal_Sym * psym = dynamic_symbols + idx;
17193
17194 print_vma (psym->st_value, LONG_HEX);
17195 printf (" %-7s %3s ",
17196 get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
17197 get_symbol_index_type (filedata, psym->st_shndx));
17198 if (VALID_DYNAMIC_NAME (psym->st_name))
17199 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
17200 else
17201 printf (_("<corrupt: %14ld>"), psym->st_name);
17202 }
17203 printf ("\n");
17204 }
17205 printf ("\n");
17206
17207 if (data)
17208 free (data);
17209 free (rels);
17210 }
17211
17212 return res;
17213 }
17214
17215 static bfd_boolean
process_nds32_specific(Filedata * filedata)17216 process_nds32_specific (Filedata * filedata)
17217 {
17218 Elf_Internal_Shdr *sect = NULL;
17219
17220 sect = find_section (filedata, ".nds32_e_flags");
17221 if (sect != NULL)
17222 {
17223 unsigned int *flag;
17224
17225 printf ("\nNDS32 elf flags section:\n");
17226 flag = get_data (NULL, filedata, sect->sh_offset, 1,
17227 sect->sh_size, _("NDS32 elf flags section"));
17228
17229 if (! flag)
17230 return FALSE;
17231
17232 switch ((*flag) & 0x3)
17233 {
17234 case 0:
17235 printf ("(VEC_SIZE):\tNo entry.\n");
17236 break;
17237 case 1:
17238 printf ("(VEC_SIZE):\t4 bytes\n");
17239 break;
17240 case 2:
17241 printf ("(VEC_SIZE):\t16 bytes\n");
17242 break;
17243 case 3:
17244 printf ("(VEC_SIZE):\treserved\n");
17245 break;
17246 }
17247 }
17248
17249 return TRUE;
17250 }
17251
17252 static bfd_boolean
process_gnu_liblist(Filedata * filedata)17253 process_gnu_liblist (Filedata * filedata)
17254 {
17255 Elf_Internal_Shdr * section;
17256 Elf_Internal_Shdr * string_sec;
17257 Elf32_External_Lib * elib;
17258 char * strtab;
17259 size_t strtab_size;
17260 size_t cnt;
17261 unsigned long num_liblist;
17262 unsigned i;
17263 bfd_boolean res = TRUE;
17264
17265 if (! do_arch)
17266 return TRUE;
17267
17268 for (i = 0, section = filedata->section_headers;
17269 i < filedata->file_header.e_shnum;
17270 i++, section++)
17271 {
17272 switch (section->sh_type)
17273 {
17274 case SHT_GNU_LIBLIST:
17275 if (section->sh_link >= filedata->file_header.e_shnum)
17276 break;
17277
17278 elib = (Elf32_External_Lib *)
17279 get_data (NULL, filedata, section->sh_offset, 1, section->sh_size,
17280 _("liblist section data"));
17281
17282 if (elib == NULL)
17283 {
17284 res = FALSE;
17285 break;
17286 }
17287
17288 string_sec = filedata->section_headers + section->sh_link;
17289 strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
17290 string_sec->sh_size,
17291 _("liblist string table"));
17292 if (strtab == NULL
17293 || section->sh_entsize != sizeof (Elf32_External_Lib))
17294 {
17295 free (elib);
17296 free (strtab);
17297 res = FALSE;
17298 break;
17299 }
17300 strtab_size = string_sec->sh_size;
17301
17302 num_liblist = section->sh_size / sizeof (Elf32_External_Lib);
17303 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17304 "\nLibrary list section '%s' contains %lu entries:\n",
17305 num_liblist),
17306 printable_section_name (filedata, section),
17307 num_liblist);
17308
17309 puts (_(" Library Time Stamp Checksum Version Flags"));
17310
17311 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
17312 ++cnt)
17313 {
17314 Elf32_Lib liblist;
17315 time_t atime;
17316 char timebuf[128];
17317 struct tm * tmp;
17318
17319 liblist.l_name = BYTE_GET (elib[cnt].l_name);
17320 atime = BYTE_GET (elib[cnt].l_time_stamp);
17321 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
17322 liblist.l_version = BYTE_GET (elib[cnt].l_version);
17323 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
17324
17325 tmp = gmtime (&atime);
17326 snprintf (timebuf, sizeof (timebuf),
17327 "%04u-%02u-%02uT%02u:%02u:%02u",
17328 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
17329 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
17330
17331 printf ("%3lu: ", (unsigned long) cnt);
17332 if (do_wide)
17333 printf ("%-20s", liblist.l_name < strtab_size
17334 ? strtab + liblist.l_name : _("<corrupt>"));
17335 else
17336 printf ("%-20.20s", liblist.l_name < strtab_size
17337 ? strtab + liblist.l_name : _("<corrupt>"));
17338 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
17339 liblist.l_version, liblist.l_flags);
17340 }
17341
17342 free (elib);
17343 free (strtab);
17344 }
17345 }
17346
17347 return res;
17348 }
17349
17350 static const char *
get_note_type(Filedata * filedata,unsigned e_type)17351 get_note_type (Filedata * filedata, unsigned e_type)
17352 {
17353 static char buff[64];
17354
17355 if (filedata->file_header.e_type == ET_CORE)
17356 switch (e_type)
17357 {
17358 case NT_AUXV:
17359 return _("NT_AUXV (auxiliary vector)");
17360 case NT_PRSTATUS:
17361 return _("NT_PRSTATUS (prstatus structure)");
17362 case NT_FPREGSET:
17363 return _("NT_FPREGSET (floating point registers)");
17364 case NT_PRPSINFO:
17365 return _("NT_PRPSINFO (prpsinfo structure)");
17366 case NT_TASKSTRUCT:
17367 return _("NT_TASKSTRUCT (task structure)");
17368 case NT_PRXFPREG:
17369 return _("NT_PRXFPREG (user_xfpregs structure)");
17370 case NT_PPC_VMX:
17371 return _("NT_PPC_VMX (ppc Altivec registers)");
17372 case NT_PPC_VSX:
17373 return _("NT_PPC_VSX (ppc VSX registers)");
17374 case NT_PPC_TAR:
17375 return _("NT_PPC_TAR (ppc TAR register)");
17376 case NT_PPC_PPR:
17377 return _("NT_PPC_PPR (ppc PPR register)");
17378 case NT_PPC_DSCR:
17379 return _("NT_PPC_DSCR (ppc DSCR register)");
17380 case NT_PPC_EBB:
17381 return _("NT_PPC_EBB (ppc EBB registers)");
17382 case NT_PPC_PMU:
17383 return _("NT_PPC_PMU (ppc PMU registers)");
17384 case NT_PPC_TM_CGPR:
17385 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17386 case NT_PPC_TM_CFPR:
17387 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17388 case NT_PPC_TM_CVMX:
17389 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17390 case NT_PPC_TM_CVSX:
17391 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17392 case NT_PPC_TM_SPR:
17393 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17394 case NT_PPC_TM_CTAR:
17395 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17396 case NT_PPC_TM_CPPR:
17397 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17398 case NT_PPC_TM_CDSCR:
17399 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17400 case NT_386_TLS:
17401 return _("NT_386_TLS (x86 TLS information)");
17402 case NT_386_IOPERM:
17403 return _("NT_386_IOPERM (x86 I/O permissions)");
17404 case NT_X86_XSTATE:
17405 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17406 case NT_S390_HIGH_GPRS:
17407 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17408 case NT_S390_TIMER:
17409 return _("NT_S390_TIMER (s390 timer register)");
17410 case NT_S390_TODCMP:
17411 return _("NT_S390_TODCMP (s390 TOD comparator register)");
17412 case NT_S390_TODPREG:
17413 return _("NT_S390_TODPREG (s390 TOD programmable register)");
17414 case NT_S390_CTRS:
17415 return _("NT_S390_CTRS (s390 control registers)");
17416 case NT_S390_PREFIX:
17417 return _("NT_S390_PREFIX (s390 prefix register)");
17418 case NT_S390_LAST_BREAK:
17419 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17420 case NT_S390_SYSTEM_CALL:
17421 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17422 case NT_S390_TDB:
17423 return _("NT_S390_TDB (s390 transaction diagnostic block)");
17424 case NT_S390_VXRS_LOW:
17425 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17426 case NT_S390_VXRS_HIGH:
17427 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17428 case NT_S390_GS_CB:
17429 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17430 case NT_S390_GS_BC:
17431 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17432 case NT_ARM_VFP:
17433 return _("NT_ARM_VFP (arm VFP registers)");
17434 case NT_ARM_TLS:
17435 return _("NT_ARM_TLS (AArch TLS registers)");
17436 case NT_ARM_HW_BREAK:
17437 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17438 case NT_ARM_HW_WATCH:
17439 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17440 case NT_PSTATUS:
17441 return _("NT_PSTATUS (pstatus structure)");
17442 case NT_FPREGS:
17443 return _("NT_FPREGS (floating point registers)");
17444 case NT_PSINFO:
17445 return _("NT_PSINFO (psinfo structure)");
17446 case NT_LWPSTATUS:
17447 return _("NT_LWPSTATUS (lwpstatus_t structure)");
17448 case NT_LWPSINFO:
17449 return _("NT_LWPSINFO (lwpsinfo_t structure)");
17450 case NT_WIN32PSTATUS:
17451 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
17452 case NT_SIGINFO:
17453 return _("NT_SIGINFO (siginfo_t data)");
17454 case NT_FILE:
17455 return _("NT_FILE (mapped files)");
17456 default:
17457 break;
17458 }
17459 else
17460 switch (e_type)
17461 {
17462 case NT_VERSION:
17463 return _("NT_VERSION (version)");
17464 case NT_ARCH:
17465 return _("NT_ARCH (architecture)");
17466 case NT_GNU_BUILD_ATTRIBUTE_OPEN:
17467 return _("OPEN");
17468 case NT_GNU_BUILD_ATTRIBUTE_FUNC:
17469 return _("func");
17470 default:
17471 break;
17472 }
17473
17474 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17475 return buff;
17476 }
17477
17478 static bfd_boolean
print_core_note(Elf_Internal_Note * pnote)17479 print_core_note (Elf_Internal_Note *pnote)
17480 {
17481 unsigned int addr_size = is_32bit_elf ? 4 : 8;
17482 bfd_vma count, page_size;
17483 unsigned char *descdata, *filenames, *descend;
17484
17485 if (pnote->type != NT_FILE)
17486 {
17487 if (do_wide)
17488 printf ("\n");
17489 return TRUE;
17490 }
17491
17492 #ifndef BFD64
17493 if (!is_32bit_elf)
17494 {
17495 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
17496 /* Still "successful". */
17497 return TRUE;
17498 }
17499 #endif
17500
17501 if (pnote->descsz < 2 * addr_size)
17502 {
17503 error (_(" Malformed note - too short for header\n"));
17504 return FALSE;
17505 }
17506
17507 descdata = (unsigned char *) pnote->descdata;
17508 descend = descdata + pnote->descsz;
17509
17510 if (descdata[pnote->descsz - 1] != '\0')
17511 {
17512 error (_(" Malformed note - does not end with \\0\n"));
17513 return FALSE;
17514 }
17515
17516 count = byte_get (descdata, addr_size);
17517 descdata += addr_size;
17518
17519 page_size = byte_get (descdata, addr_size);
17520 descdata += addr_size;
17521
17522 if (count > ((bfd_vma) -1 - 2 * addr_size) / (3 * addr_size)
17523 || pnote->descsz < 2 * addr_size + count * 3 * addr_size)
17524 {
17525 error (_(" Malformed note - too short for supplied file count\n"));
17526 return FALSE;
17527 }
17528
17529 printf (_(" Page size: "));
17530 print_vma (page_size, DEC);
17531 printf ("\n");
17532
17533 printf (_(" %*s%*s%*s\n"),
17534 (int) (2 + 2 * addr_size), _("Start"),
17535 (int) (4 + 2 * addr_size), _("End"),
17536 (int) (4 + 2 * addr_size), _("Page Offset"));
17537 filenames = descdata + count * 3 * addr_size;
17538 while (count-- > 0)
17539 {
17540 bfd_vma start, end, file_ofs;
17541
17542 if (filenames == descend)
17543 {
17544 error (_(" Malformed note - filenames end too early\n"));
17545 return FALSE;
17546 }
17547
17548 start = byte_get (descdata, addr_size);
17549 descdata += addr_size;
17550 end = byte_get (descdata, addr_size);
17551 descdata += addr_size;
17552 file_ofs = byte_get (descdata, addr_size);
17553 descdata += addr_size;
17554
17555 printf (" ");
17556 print_vma (start, FULL_HEX);
17557 printf (" ");
17558 print_vma (end, FULL_HEX);
17559 printf (" ");
17560 print_vma (file_ofs, FULL_HEX);
17561 printf ("\n %s\n", filenames);
17562
17563 filenames += 1 + strlen ((char *) filenames);
17564 }
17565
17566 return TRUE;
17567 }
17568
17569 static const char *
get_gnu_elf_note_type(unsigned e_type)17570 get_gnu_elf_note_type (unsigned e_type)
17571 {
17572 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
17573 switch (e_type)
17574 {
17575 case NT_GNU_ABI_TAG:
17576 return _("NT_GNU_ABI_TAG (ABI version tag)");
17577 case NT_GNU_HWCAP:
17578 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17579 case NT_GNU_BUILD_ID:
17580 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17581 case NT_GNU_GOLD_VERSION:
17582 return _("NT_GNU_GOLD_VERSION (gold version)");
17583 case NT_GNU_PROPERTY_TYPE_0:
17584 return _("NT_GNU_PROPERTY_TYPE_0");
17585 case NT_GNU_BUILD_ATTRIBUTE_OPEN:
17586 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17587 case NT_GNU_BUILD_ATTRIBUTE_FUNC:
17588 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17589 default:
17590 {
17591 static char buff[64];
17592
17593 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17594 return buff;
17595 }
17596 }
17597 }
17598
17599 static void
decode_x86_compat_isa(unsigned int bitmask)17600 decode_x86_compat_isa (unsigned int bitmask)
17601 {
17602 while (bitmask)
17603 {
17604 unsigned int bit = bitmask & (- bitmask);
17605
17606 bitmask &= ~ bit;
17607 switch (bit)
17608 {
17609 case GNU_PROPERTY_X86_COMPAT_ISA_1_486:
17610 printf ("i486");
17611 break;
17612 case GNU_PROPERTY_X86_COMPAT_ISA_1_586:
17613 printf ("586");
17614 break;
17615 case GNU_PROPERTY_X86_COMPAT_ISA_1_686:
17616 printf ("686");
17617 break;
17618 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE:
17619 printf ("SSE");
17620 break;
17621 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2:
17622 printf ("SSE2");
17623 break;
17624 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3:
17625 printf ("SSE3");
17626 break;
17627 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3:
17628 printf ("SSSE3");
17629 break;
17630 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1:
17631 printf ("SSE4_1");
17632 break;
17633 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2:
17634 printf ("SSE4_2");
17635 break;
17636 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX:
17637 printf ("AVX");
17638 break;
17639 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2:
17640 printf ("AVX2");
17641 break;
17642 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F:
17643 printf ("AVX512F");
17644 break;
17645 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD:
17646 printf ("AVX512CD");
17647 break;
17648 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER:
17649 printf ("AVX512ER");
17650 break;
17651 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF:
17652 printf ("AVX512PF");
17653 break;
17654 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL:
17655 printf ("AVX512VL");
17656 break;
17657 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ:
17658 printf ("AVX512DQ");
17659 break;
17660 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW:
17661 printf ("AVX512BW");
17662 break;
17663 default:
17664 printf (_("<unknown: %x>"), bit);
17665 break;
17666 }
17667 if (bitmask)
17668 printf (", ");
17669 }
17670 }
17671
17672 static void
decode_x86_isa(unsigned int bitmask)17673 decode_x86_isa (unsigned int bitmask)
17674 {
17675 if (!bitmask)
17676 {
17677 printf (_("<None>"));
17678 return;
17679 }
17680
17681 while (bitmask)
17682 {
17683 unsigned int bit = bitmask & (- bitmask);
17684
17685 bitmask &= ~ bit;
17686 switch (bit)
17687 {
17688 case GNU_PROPERTY_X86_ISA_1_CMOV:
17689 printf ("CMOV");
17690 break;
17691 case GNU_PROPERTY_X86_ISA_1_SSE:
17692 printf ("SSE");
17693 break;
17694 case GNU_PROPERTY_X86_ISA_1_SSE2:
17695 printf ("SSE2");
17696 break;
17697 case GNU_PROPERTY_X86_ISA_1_SSE3:
17698 printf ("SSE3");
17699 break;
17700 case GNU_PROPERTY_X86_ISA_1_SSSE3:
17701 printf ("SSSE3");
17702 break;
17703 case GNU_PROPERTY_X86_ISA_1_SSE4_1:
17704 printf ("SSE4_1");
17705 break;
17706 case GNU_PROPERTY_X86_ISA_1_SSE4_2:
17707 printf ("SSE4_2");
17708 break;
17709 case GNU_PROPERTY_X86_ISA_1_AVX:
17710 printf ("AVX");
17711 break;
17712 case GNU_PROPERTY_X86_ISA_1_AVX2:
17713 printf ("AVX2");
17714 break;
17715 case GNU_PROPERTY_X86_ISA_1_FMA:
17716 printf ("FMA");
17717 break;
17718 case GNU_PROPERTY_X86_ISA_1_AVX512F:
17719 printf ("AVX512F");
17720 break;
17721 case GNU_PROPERTY_X86_ISA_1_AVX512CD:
17722 printf ("AVX512CD");
17723 break;
17724 case GNU_PROPERTY_X86_ISA_1_AVX512ER:
17725 printf ("AVX512ER");
17726 break;
17727 case GNU_PROPERTY_X86_ISA_1_AVX512PF:
17728 printf ("AVX512PF");
17729 break;
17730 case GNU_PROPERTY_X86_ISA_1_AVX512VL:
17731 printf ("AVX512VL");
17732 break;
17733 case GNU_PROPERTY_X86_ISA_1_AVX512DQ:
17734 printf ("AVX512DQ");
17735 break;
17736 case GNU_PROPERTY_X86_ISA_1_AVX512BW:
17737 printf ("AVX512BW");
17738 break;
17739 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS:
17740 printf ("AVX512_4FMAPS");
17741 break;
17742 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW:
17743 printf ("AVX512_4VNNIW");
17744 break;
17745 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG:
17746 printf ("AVX512_BITALG");
17747 break;
17748 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA:
17749 printf ("AVX512_IFMA");
17750 break;
17751 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI:
17752 printf ("AVX512_VBMI");
17753 break;
17754 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2:
17755 printf ("AVX512_VBMI2");
17756 break;
17757 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI:
17758 printf ("AVX512_VNNI");
17759 break;
17760 case GNU_PROPERTY_X86_ISA_1_AVX512_BF16:
17761 printf ("AVX512_BF16");
17762 break;
17763 default:
17764 printf (_("<unknown: %x>"), bit);
17765 break;
17766 }
17767 if (bitmask)
17768 printf (", ");
17769 }
17770 }
17771
17772 static void
decode_x86_feature_1(unsigned int bitmask)17773 decode_x86_feature_1 (unsigned int bitmask)
17774 {
17775 if (!bitmask)
17776 {
17777 printf (_("<None>"));
17778 return;
17779 }
17780
17781 while (bitmask)
17782 {
17783 unsigned int bit = bitmask & (- bitmask);
17784
17785 bitmask &= ~ bit;
17786 switch (bit)
17787 {
17788 case GNU_PROPERTY_X86_FEATURE_1_IBT:
17789 printf ("IBT");
17790 break;
17791 case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
17792 printf ("SHSTK");
17793 break;
17794 default:
17795 printf (_("<unknown: %x>"), bit);
17796 break;
17797 }
17798 if (bitmask)
17799 printf (", ");
17800 }
17801 }
17802
17803 static void
decode_x86_feature_2(unsigned int bitmask)17804 decode_x86_feature_2 (unsigned int bitmask)
17805 {
17806 if (!bitmask)
17807 {
17808 printf (_("<None>"));
17809 return;
17810 }
17811
17812 while (bitmask)
17813 {
17814 unsigned int bit = bitmask & (- bitmask);
17815
17816 bitmask &= ~ bit;
17817 switch (bit)
17818 {
17819 case GNU_PROPERTY_X86_FEATURE_2_X86:
17820 printf ("x86");
17821 break;
17822 case GNU_PROPERTY_X86_FEATURE_2_X87:
17823 printf ("x87");
17824 break;
17825 case GNU_PROPERTY_X86_FEATURE_2_MMX:
17826 printf ("MMX");
17827 break;
17828 case GNU_PROPERTY_X86_FEATURE_2_XMM:
17829 printf ("XMM");
17830 break;
17831 case GNU_PROPERTY_X86_FEATURE_2_YMM:
17832 printf ("YMM");
17833 break;
17834 case GNU_PROPERTY_X86_FEATURE_2_ZMM:
17835 printf ("ZMM");
17836 break;
17837 case GNU_PROPERTY_X86_FEATURE_2_FXSR:
17838 printf ("FXSR");
17839 break;
17840 case GNU_PROPERTY_X86_FEATURE_2_XSAVE:
17841 printf ("XSAVE");
17842 break;
17843 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT:
17844 printf ("XSAVEOPT");
17845 break;
17846 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC:
17847 printf ("XSAVEC");
17848 break;
17849 default:
17850 printf (_("<unknown: %x>"), bit);
17851 break;
17852 }
17853 if (bitmask)
17854 printf (", ");
17855 }
17856 }
17857
17858 static void
decode_aarch64_feature_1_and(unsigned int bitmask)17859 decode_aarch64_feature_1_and (unsigned int bitmask)
17860 {
17861 while (bitmask)
17862 {
17863 unsigned int bit = bitmask & (- bitmask);
17864
17865 bitmask &= ~ bit;
17866 switch (bit)
17867 {
17868 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI:
17869 printf ("BTI");
17870 break;
17871
17872 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC:
17873 printf ("PAC");
17874 break;
17875
17876 default:
17877 printf (_("<unknown: %x>"), bit);
17878 break;
17879 }
17880 if (bitmask)
17881 printf (", ");
17882 }
17883 }
17884
17885 static void
print_gnu_property_note(Filedata * filedata,Elf_Internal_Note * pnote)17886 print_gnu_property_note (Filedata * filedata, Elf_Internal_Note * pnote)
17887 {
17888 unsigned char * ptr = (unsigned char *) pnote->descdata;
17889 unsigned char * ptr_end = ptr + pnote->descsz;
17890 unsigned int size = is_32bit_elf ? 4 : 8;
17891
17892 printf (_(" Properties: "));
17893
17894 if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
17895 {
17896 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
17897 return;
17898 }
17899
17900 while (ptr < ptr_end)
17901 {
17902 unsigned int j;
17903 unsigned int type;
17904 unsigned int datasz;
17905
17906 if ((size_t) (ptr_end - ptr) < 8)
17907 {
17908 printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
17909 break;
17910 }
17911
17912 type = byte_get (ptr, 4);
17913 datasz = byte_get (ptr + 4, 4);
17914
17915 ptr += 8;
17916
17917 if (datasz > (size_t) (ptr_end - ptr))
17918 {
17919 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
17920 type, datasz);
17921 break;
17922 }
17923
17924 if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
17925 {
17926 if (filedata->file_header.e_machine == EM_X86_64
17927 || filedata->file_header.e_machine == EM_IAMCU
17928 || filedata->file_header.e_machine == EM_386)
17929 {
17930 unsigned int bitmask;
17931
17932 if (datasz == 4)
17933 bitmask = byte_get (ptr, 4);
17934 else
17935 bitmask = 0;
17936
17937 switch (type)
17938 {
17939 case GNU_PROPERTY_X86_ISA_1_USED:
17940 if (datasz != 4)
17941 printf (_("x86 ISA used: <corrupt length: %#x> "),
17942 datasz);
17943 else
17944 {
17945 printf ("x86 ISA used: ");
17946 decode_x86_isa (bitmask);
17947 }
17948 goto next;
17949
17950 case GNU_PROPERTY_X86_ISA_1_NEEDED:
17951 if (datasz != 4)
17952 printf (_("x86 ISA needed: <corrupt length: %#x> "),
17953 datasz);
17954 else
17955 {
17956 printf ("x86 ISA needed: ");
17957 decode_x86_isa (bitmask);
17958 }
17959 goto next;
17960
17961 case GNU_PROPERTY_X86_FEATURE_1_AND:
17962 if (datasz != 4)
17963 printf (_("x86 feature: <corrupt length: %#x> "),
17964 datasz);
17965 else
17966 {
17967 printf ("x86 feature: ");
17968 decode_x86_feature_1 (bitmask);
17969 }
17970 goto next;
17971
17972 case GNU_PROPERTY_X86_FEATURE_2_USED:
17973 if (datasz != 4)
17974 printf (_("x86 feature used: <corrupt length: %#x> "),
17975 datasz);
17976 else
17977 {
17978 printf ("x86 feature used: ");
17979 decode_x86_feature_2 (bitmask);
17980 }
17981 goto next;
17982
17983 case GNU_PROPERTY_X86_FEATURE_2_NEEDED:
17984 if (datasz != 4)
17985 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz);
17986 else
17987 {
17988 printf ("x86 feature needed: ");
17989 decode_x86_feature_2 (bitmask);
17990 }
17991 goto next;
17992
17993 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED:
17994 if (datasz != 4)
17995 printf (_("x86 ISA used: <corrupt length: %#x> "),
17996 datasz);
17997 else
17998 {
17999 printf ("x86 ISA used: ");
18000 decode_x86_compat_isa (bitmask);
18001 }
18002 goto next;
18003
18004 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED:
18005 if (datasz != 4)
18006 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18007 datasz);
18008 else
18009 {
18010 printf ("x86 ISA needed: ");
18011 decode_x86_compat_isa (bitmask);
18012 }
18013 goto next;
18014
18015 default:
18016 break;
18017 }
18018 }
18019 else if (filedata->file_header.e_machine == EM_AARCH64)
18020 {
18021 if (type == GNU_PROPERTY_AARCH64_FEATURE_1_AND)
18022 {
18023 printf ("AArch64 feature: ");
18024 if (datasz != 4)
18025 printf (_("<corrupt length: %#x> "), datasz);
18026 else
18027 decode_aarch64_feature_1_and (byte_get (ptr, 4));
18028 goto next;
18029 }
18030 }
18031 }
18032 else
18033 {
18034 switch (type)
18035 {
18036 case GNU_PROPERTY_STACK_SIZE:
18037 printf (_("stack size: "));
18038 if (datasz != size)
18039 printf (_("<corrupt length: %#x> "), datasz);
18040 else
18041 printf ("%#lx", (unsigned long) byte_get (ptr, size));
18042 goto next;
18043
18044 case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
18045 printf ("no copy on protected ");
18046 if (datasz)
18047 printf (_("<corrupt length: %#x> "), datasz);
18048 goto next;
18049
18050 default:
18051 break;
18052 }
18053 }
18054
18055 if (type < GNU_PROPERTY_LOPROC)
18056 printf (_("<unknown type %#x data: "), type);
18057 else if (type < GNU_PROPERTY_LOUSER)
18058 printf (_("<procesor-specific type %#x data: "), type);
18059 else
18060 printf (_("<application-specific type %#x data: "), type);
18061 for (j = 0; j < datasz; ++j)
18062 printf ("%02x ", ptr[j] & 0xff);
18063 printf (">");
18064
18065 next:
18066 ptr += ((datasz + (size - 1)) & ~ (size - 1));
18067 if (ptr == ptr_end)
18068 break;
18069
18070 if (do_wide)
18071 printf (", ");
18072 else
18073 printf ("\n\t");
18074 }
18075
18076 printf ("\n");
18077 }
18078
18079 static bfd_boolean
print_gnu_note(Filedata * filedata,Elf_Internal_Note * pnote)18080 print_gnu_note (Filedata * filedata, Elf_Internal_Note *pnote)
18081 {
18082 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
18083 switch (pnote->type)
18084 {
18085 case NT_GNU_BUILD_ID:
18086 {
18087 unsigned long i;
18088
18089 printf (_(" Build ID: "));
18090 for (i = 0; i < pnote->descsz; ++i)
18091 printf ("%02x", pnote->descdata[i] & 0xff);
18092 printf ("\n");
18093 }
18094 break;
18095
18096 case NT_GNU_ABI_TAG:
18097 {
18098 unsigned long os, major, minor, subminor;
18099 const char *osname;
18100
18101 /* PR 17531: file: 030-599401-0.004. */
18102 if (pnote->descsz < 16)
18103 {
18104 printf (_(" <corrupt GNU_ABI_TAG>\n"));
18105 break;
18106 }
18107
18108 os = byte_get ((unsigned char *) pnote->descdata, 4);
18109 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
18110 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
18111 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
18112
18113 switch (os)
18114 {
18115 case GNU_ABI_TAG_LINUX:
18116 osname = "Linux";
18117 break;
18118 case GNU_ABI_TAG_HURD:
18119 osname = "Hurd";
18120 break;
18121 case GNU_ABI_TAG_SOLARIS:
18122 osname = "Solaris";
18123 break;
18124 case GNU_ABI_TAG_FREEBSD:
18125 osname = "FreeBSD";
18126 break;
18127 case GNU_ABI_TAG_NETBSD:
18128 osname = "NetBSD";
18129 break;
18130 case GNU_ABI_TAG_SYLLABLE:
18131 osname = "Syllable";
18132 break;
18133 case GNU_ABI_TAG_NACL:
18134 osname = "NaCl";
18135 break;
18136 default:
18137 osname = "Unknown";
18138 break;
18139 }
18140
18141 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
18142 major, minor, subminor);
18143 }
18144 break;
18145
18146 case NT_GNU_GOLD_VERSION:
18147 {
18148 unsigned long i;
18149
18150 printf (_(" Version: "));
18151 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
18152 printf ("%c", pnote->descdata[i]);
18153 printf ("\n");
18154 }
18155 break;
18156
18157 case NT_GNU_HWCAP:
18158 {
18159 unsigned long num_entries, mask;
18160
18161 /* Hardware capabilities information. Word 0 is the number of entries.
18162 Word 1 is a bitmask of enabled entries. The rest of the descriptor
18163 is a series of entries, where each entry is a single byte followed
18164 by a nul terminated string. The byte gives the bit number to test
18165 if enabled in the bitmask. */
18166 printf (_(" Hardware Capabilities: "));
18167 if (pnote->descsz < 8)
18168 {
18169 error (_("<corrupt GNU_HWCAP>\n"));
18170 return FALSE;
18171 }
18172 num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
18173 mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
18174 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
18175 /* FIXME: Add code to display the entries... */
18176 }
18177 break;
18178
18179 case NT_GNU_PROPERTY_TYPE_0:
18180 print_gnu_property_note (filedata, pnote);
18181 break;
18182
18183 default:
18184 /* Handle unrecognised types. An error message should have already been
18185 created by get_gnu_elf_note_type(), so all that we need to do is to
18186 display the data. */
18187 {
18188 unsigned long i;
18189
18190 printf (_(" Description data: "));
18191 for (i = 0; i < pnote->descsz; ++i)
18192 printf ("%02x ", pnote->descdata[i] & 0xff);
18193 printf ("\n");
18194 }
18195 break;
18196 }
18197
18198 return TRUE;
18199 }
18200
18201 static const char *
get_v850_elf_note_type(enum v850_notes n_type)18202 get_v850_elf_note_type (enum v850_notes n_type)
18203 {
18204 static char buff[64];
18205
18206 switch (n_type)
18207 {
18208 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
18209 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
18210 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
18211 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
18212 case V850_NOTE_CACHE_INFO: return _("Use of cache");
18213 case V850_NOTE_MMU_INFO: return _("Use of MMU");
18214 default:
18215 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
18216 return buff;
18217 }
18218 }
18219
18220 static bfd_boolean
print_v850_note(Elf_Internal_Note * pnote)18221 print_v850_note (Elf_Internal_Note * pnote)
18222 {
18223 unsigned int val;
18224
18225 if (pnote->descsz != 4)
18226 return FALSE;
18227
18228 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
18229
18230 if (val == 0)
18231 {
18232 printf (_("not set\n"));
18233 return TRUE;
18234 }
18235
18236 switch (pnote->type)
18237 {
18238 case V850_NOTE_ALIGNMENT:
18239 switch (val)
18240 {
18241 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
18242 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
18243 }
18244 break;
18245
18246 case V850_NOTE_DATA_SIZE:
18247 switch (val)
18248 {
18249 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
18250 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
18251 }
18252 break;
18253
18254 case V850_NOTE_FPU_INFO:
18255 switch (val)
18256 {
18257 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
18258 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
18259 }
18260 break;
18261
18262 case V850_NOTE_MMU_INFO:
18263 case V850_NOTE_CACHE_INFO:
18264 case V850_NOTE_SIMD_INFO:
18265 if (val == EF_RH850_SIMD)
18266 {
18267 printf (_("yes\n"));
18268 return TRUE;
18269 }
18270 break;
18271
18272 default:
18273 /* An 'unknown note type' message will already have been displayed. */
18274 break;
18275 }
18276
18277 printf (_("unknown value: %x\n"), val);
18278 return FALSE;
18279 }
18280
18281 static bfd_boolean
process_netbsd_elf_note(Elf_Internal_Note * pnote)18282 process_netbsd_elf_note (Elf_Internal_Note * pnote)
18283 {
18284 unsigned int version;
18285
18286 switch (pnote->type)
18287 {
18288 case NT_NETBSD_IDENT:
18289 version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
18290 if ((version / 10000) % 100)
18291 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
18292 version, version / 100000000, (version / 1000000) % 100,
18293 (version / 10000) % 100 > 26 ? "Z" : "",
18294 'A' + (version / 10000) % 26);
18295 else
18296 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
18297 version, version / 100000000, (version / 1000000) % 100,
18298 (version / 100) % 100);
18299 return TRUE;
18300
18301 case NT_NETBSD_MARCH:
18302 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
18303 pnote->descdata);
18304 return TRUE;
18305
18306 #ifdef NT_NETBSD_PAX
18307 case NT_NETBSD_PAX:
18308 version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
18309 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote->descsz,
18310 ((version & NT_NETBSD_PAX_MPROTECT) ? "+mprotect" : ""),
18311 ((version & NT_NETBSD_PAX_NOMPROTECT) ? "-mprotect" : ""),
18312 ((version & NT_NETBSD_PAX_GUARD) ? "+guard" : ""),
18313 ((version & NT_NETBSD_PAX_NOGUARD) ? "-guard" : ""),
18314 ((version & NT_NETBSD_PAX_ASLR) ? "+ASLR" : ""),
18315 ((version & NT_NETBSD_PAX_NOASLR) ? "-ASLR" : ""));
18316 return TRUE;
18317 #endif
18318
18319 default:
18320 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
18321 pnote->type);
18322 return FALSE;
18323 }
18324 }
18325
18326 static const char *
get_freebsd_elfcore_note_type(Filedata * filedata,unsigned e_type)18327 get_freebsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
18328 {
18329 switch (e_type)
18330 {
18331 case NT_FREEBSD_THRMISC:
18332 return _("NT_THRMISC (thrmisc structure)");
18333 case NT_FREEBSD_PROCSTAT_PROC:
18334 return _("NT_PROCSTAT_PROC (proc data)");
18335 case NT_FREEBSD_PROCSTAT_FILES:
18336 return _("NT_PROCSTAT_FILES (files data)");
18337 case NT_FREEBSD_PROCSTAT_VMMAP:
18338 return _("NT_PROCSTAT_VMMAP (vmmap data)");
18339 case NT_FREEBSD_PROCSTAT_GROUPS:
18340 return _("NT_PROCSTAT_GROUPS (groups data)");
18341 case NT_FREEBSD_PROCSTAT_UMASK:
18342 return _("NT_PROCSTAT_UMASK (umask data)");
18343 case NT_FREEBSD_PROCSTAT_RLIMIT:
18344 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18345 case NT_FREEBSD_PROCSTAT_OSREL:
18346 return _("NT_PROCSTAT_OSREL (osreldate data)");
18347 case NT_FREEBSD_PROCSTAT_PSSTRINGS:
18348 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18349 case NT_FREEBSD_PROCSTAT_AUXV:
18350 return _("NT_PROCSTAT_AUXV (auxv data)");
18351 case NT_FREEBSD_PTLWPINFO:
18352 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18353 }
18354 return get_note_type (filedata, e_type);
18355 }
18356
18357 static const char *
get_netbsd_elfcore_note_type(Filedata * filedata,unsigned e_type)18358 get_netbsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
18359 {
18360 static char buff[64];
18361
18362 switch (e_type)
18363 {
18364 case NT_NETBSDCORE_PROCINFO:
18365 /* NetBSD core "procinfo" structure. */
18366 return _("NetBSD procinfo structure");
18367
18368 #ifdef NT_NETBSDCORE_AUXV
18369 case NT_NETBSDCORE_AUXV:
18370 return _("NetBSD ELF auxiliary vector data");
18371 #endif
18372
18373 default:
18374 /* As of Jan 2002 there are no other machine-independent notes
18375 defined for NetBSD core files. If the note type is less
18376 than the start of the machine-dependent note types, we don't
18377 understand it. */
18378
18379 if (e_type < NT_NETBSDCORE_FIRSTMACH)
18380 {
18381 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
18382 return buff;
18383 }
18384 break;
18385 }
18386
18387 switch (filedata->file_header.e_machine)
18388 {
18389 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18390 and PT_GETFPREGS == mach+2. */
18391
18392 case EM_OLD_ALPHA:
18393 case EM_ALPHA:
18394 case EM_SPARC:
18395 case EM_SPARC32PLUS:
18396 case EM_SPARCV9:
18397 switch (e_type)
18398 {
18399 case NT_NETBSDCORE_FIRSTMACH + 0:
18400 return _("PT_GETREGS (reg structure)");
18401 case NT_NETBSDCORE_FIRSTMACH + 2:
18402 return _("PT_GETFPREGS (fpreg structure)");
18403 default:
18404 break;
18405 }
18406 break;
18407
18408 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
18409 There's also old PT___GETREGS40 == mach + 1 for old reg
18410 structure which lacks GBR. */
18411 case EM_SH:
18412 switch (e_type)
18413 {
18414 case NT_NETBSDCORE_FIRSTMACH + 1:
18415 return _("PT___GETREGS40 (old reg structure)");
18416 case NT_NETBSDCORE_FIRSTMACH + 3:
18417 return _("PT_GETREGS (reg structure)");
18418 case NT_NETBSDCORE_FIRSTMACH + 5:
18419 return _("PT_GETFPREGS (fpreg structure)");
18420 default:
18421 break;
18422 }
18423 break;
18424
18425 /* On all other arch's, PT_GETREGS == mach+1 and
18426 PT_GETFPREGS == mach+3. */
18427 default:
18428 switch (e_type)
18429 {
18430 case NT_NETBSDCORE_FIRSTMACH + 1:
18431 return _("PT_GETREGS (reg structure)");
18432 case NT_NETBSDCORE_FIRSTMACH + 3:
18433 return _("PT_GETFPREGS (fpreg structure)");
18434 default:
18435 break;
18436 }
18437 }
18438
18439 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
18440 e_type - NT_NETBSDCORE_FIRSTMACH);
18441 return buff;
18442 }
18443
18444 static const char *
get_stapsdt_note_type(unsigned e_type)18445 get_stapsdt_note_type (unsigned e_type)
18446 {
18447 static char buff[64];
18448
18449 switch (e_type)
18450 {
18451 case NT_STAPSDT:
18452 return _("NT_STAPSDT (SystemTap probe descriptors)");
18453
18454 default:
18455 break;
18456 }
18457
18458 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
18459 return buff;
18460 }
18461
18462 static bfd_boolean
print_stapsdt_note(Elf_Internal_Note * pnote)18463 print_stapsdt_note (Elf_Internal_Note *pnote)
18464 {
18465 size_t len, maxlen;
18466 unsigned long addr_size = is_32bit_elf ? 4 : 8;
18467 char *data = pnote->descdata;
18468 char *data_end = pnote->descdata + pnote->descsz;
18469 bfd_vma pc, base_addr, semaphore;
18470 char *provider, *probe, *arg_fmt;
18471
18472 if (pnote->descsz < (addr_size * 3))
18473 goto stapdt_note_too_small;
18474
18475 pc = byte_get ((unsigned char *) data, addr_size);
18476 data += addr_size;
18477
18478 base_addr = byte_get ((unsigned char *) data, addr_size);
18479 data += addr_size;
18480
18481 semaphore = byte_get ((unsigned char *) data, addr_size);
18482 data += addr_size;
18483
18484 if (data >= data_end)
18485 goto stapdt_note_too_small;
18486 maxlen = data_end - data;
18487 len = strnlen (data, maxlen);
18488 if (len < maxlen)
18489 {
18490 provider = data;
18491 data += len + 1;
18492 }
18493 else
18494 goto stapdt_note_too_small;
18495
18496 if (data >= data_end)
18497 goto stapdt_note_too_small;
18498 maxlen = data_end - data;
18499 len = strnlen (data, maxlen);
18500 if (len < maxlen)
18501 {
18502 probe = data;
18503 data += len + 1;
18504 }
18505 else
18506 goto stapdt_note_too_small;
18507
18508 if (data >= data_end)
18509 goto stapdt_note_too_small;
18510 maxlen = data_end - data;
18511 len = strnlen (data, maxlen);
18512 if (len < maxlen)
18513 {
18514 arg_fmt = data;
18515 data += len + 1;
18516 }
18517 else
18518 goto stapdt_note_too_small;
18519
18520 printf (_(" Provider: %s\n"), provider);
18521 printf (_(" Name: %s\n"), probe);
18522 printf (_(" Location: "));
18523 print_vma (pc, FULL_HEX);
18524 printf (_(", Base: "));
18525 print_vma (base_addr, FULL_HEX);
18526 printf (_(", Semaphore: "));
18527 print_vma (semaphore, FULL_HEX);
18528 printf ("\n");
18529 printf (_(" Arguments: %s\n"), arg_fmt);
18530
18531 return data == data_end;
18532
18533 stapdt_note_too_small:
18534 printf (_(" <corrupt - note is too small>\n"));
18535 error (_("corrupt stapdt note - the data size is too small\n"));
18536 return FALSE;
18537 }
18538
18539 static const char *
get_ia64_vms_note_type(unsigned e_type)18540 get_ia64_vms_note_type (unsigned e_type)
18541 {
18542 static char buff[64];
18543
18544 switch (e_type)
18545 {
18546 case NT_VMS_MHD:
18547 return _("NT_VMS_MHD (module header)");
18548 case NT_VMS_LNM:
18549 return _("NT_VMS_LNM (language name)");
18550 case NT_VMS_SRC:
18551 return _("NT_VMS_SRC (source files)");
18552 case NT_VMS_TITLE:
18553 return "NT_VMS_TITLE";
18554 case NT_VMS_EIDC:
18555 return _("NT_VMS_EIDC (consistency check)");
18556 case NT_VMS_FPMODE:
18557 return _("NT_VMS_FPMODE (FP mode)");
18558 case NT_VMS_LINKTIME:
18559 return "NT_VMS_LINKTIME";
18560 case NT_VMS_IMGNAM:
18561 return _("NT_VMS_IMGNAM (image name)");
18562 case NT_VMS_IMGID:
18563 return _("NT_VMS_IMGID (image id)");
18564 case NT_VMS_LINKID:
18565 return _("NT_VMS_LINKID (link id)");
18566 case NT_VMS_IMGBID:
18567 return _("NT_VMS_IMGBID (build id)");
18568 case NT_VMS_GSTNAM:
18569 return _("NT_VMS_GSTNAM (sym table name)");
18570 case NT_VMS_ORIG_DYN:
18571 return "NT_VMS_ORIG_DYN";
18572 case NT_VMS_PATCHTIME:
18573 return "NT_VMS_PATCHTIME";
18574 default:
18575 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
18576 return buff;
18577 }
18578 }
18579
18580 static bfd_boolean
print_ia64_vms_note(Elf_Internal_Note * pnote)18581 print_ia64_vms_note (Elf_Internal_Note * pnote)
18582 {
18583 int maxlen = pnote->descsz;
18584
18585 if (maxlen < 2 || (unsigned long) maxlen != pnote->descsz)
18586 goto desc_size_fail;
18587
18588 switch (pnote->type)
18589 {
18590 case NT_VMS_MHD:
18591 if (maxlen <= 36)
18592 goto desc_size_fail;
18593
18594 int l = (int) strnlen (pnote->descdata + 34, maxlen - 34);
18595
18596 printf (_(" Creation date : %.17s\n"), pnote->descdata);
18597 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
18598 if (l + 34 < maxlen)
18599 {
18600 printf (_(" Module name : %s\n"), pnote->descdata + 34);
18601 if (l + 35 < maxlen)
18602 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
18603 else
18604 printf (_(" Module version : <missing>\n"));
18605 }
18606 else
18607 {
18608 printf (_(" Module name : <missing>\n"));
18609 printf (_(" Module version : <missing>\n"));
18610 }
18611 break;
18612
18613 case NT_VMS_LNM:
18614 printf (_(" Language: %.*s\n"), maxlen, pnote->descdata);
18615 break;
18616
18617 #ifdef BFD64
18618 case NT_VMS_FPMODE:
18619 printf (_(" Floating Point mode: "));
18620 if (maxlen < 8)
18621 goto desc_size_fail;
18622 /* FIXME: Generate an error if descsz > 8 ? */
18623
18624 printf ("0x%016" BFD_VMA_FMT "x\n",
18625 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
18626 break;
18627
18628 case NT_VMS_LINKTIME:
18629 printf (_(" Link time: "));
18630 if (maxlen < 8)
18631 goto desc_size_fail;
18632 /* FIXME: Generate an error if descsz > 8 ? */
18633
18634 print_vms_time
18635 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
18636 printf ("\n");
18637 break;
18638
18639 case NT_VMS_PATCHTIME:
18640 printf (_(" Patch time: "));
18641 if (maxlen < 8)
18642 goto desc_size_fail;
18643 /* FIXME: Generate an error if descsz > 8 ? */
18644
18645 print_vms_time
18646 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
18647 printf ("\n");
18648 break;
18649
18650 case NT_VMS_ORIG_DYN:
18651 if (maxlen < 34)
18652 goto desc_size_fail;
18653
18654 printf (_(" Major id: %u, minor id: %u\n"),
18655 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
18656 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
18657 printf (_(" Last modified : "));
18658 print_vms_time
18659 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
18660 printf (_("\n Link flags : "));
18661 printf ("0x%016" BFD_VMA_FMT "x\n",
18662 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
18663 printf (_(" Header flags: 0x%08x\n"),
18664 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
18665 printf (_(" Image id : %.*s\n"), maxlen - 32, pnote->descdata + 32);
18666 break;
18667 #endif
18668
18669 case NT_VMS_IMGNAM:
18670 printf (_(" Image name: %.*s\n"), maxlen, pnote->descdata);
18671 break;
18672
18673 case NT_VMS_GSTNAM:
18674 printf (_(" Global symbol table name: %.*s\n"), maxlen, pnote->descdata);
18675 break;
18676
18677 case NT_VMS_IMGID:
18678 printf (_(" Image id: %.*s\n"), maxlen, pnote->descdata);
18679 break;
18680
18681 case NT_VMS_LINKID:
18682 printf (_(" Linker id: %.*s\n"), maxlen, pnote->descdata);
18683 break;
18684
18685 default:
18686 return FALSE;
18687 }
18688
18689 return TRUE;
18690
18691 desc_size_fail:
18692 printf (_(" <corrupt - data size is too small>\n"));
18693 error (_("corrupt IA64 note: data size is too small\n"));
18694 return FALSE;
18695 }
18696
18697 /* Find the symbol associated with a build attribute that is attached
18698 to address OFFSET. If PNAME is non-NULL then store the name of
18699 the symbol (if found) in the provided pointer, Returns NULL if a
18700 symbol could not be found. */
18701
18702 static Elf_Internal_Sym *
get_symbol_for_build_attribute(Filedata * filedata,unsigned long offset,bfd_boolean is_open_attr,const char ** pname)18703 get_symbol_for_build_attribute (Filedata * filedata,
18704 unsigned long offset,
18705 bfd_boolean is_open_attr,
18706 const char ** pname)
18707 {
18708 static Filedata * saved_filedata = NULL;
18709 static char * strtab;
18710 static unsigned long strtablen;
18711 static Elf_Internal_Sym * symtab;
18712 static unsigned long nsyms;
18713 Elf_Internal_Sym * saved_sym = NULL;
18714 Elf_Internal_Sym * sym;
18715
18716 if (filedata->section_headers != NULL
18717 && (saved_filedata == NULL || filedata != saved_filedata))
18718 {
18719 Elf_Internal_Shdr * symsec;
18720
18721 /* Load the symbol and string sections. */
18722 for (symsec = filedata->section_headers;
18723 symsec < filedata->section_headers + filedata->file_header.e_shnum;
18724 symsec ++)
18725 {
18726 if (symsec->sh_type == SHT_SYMTAB)
18727 {
18728 symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
18729
18730 if (symsec->sh_link < filedata->file_header.e_shnum)
18731 {
18732 Elf_Internal_Shdr * strtab_sec = filedata->section_headers + symsec->sh_link;
18733
18734 strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
18735 1, strtab_sec->sh_size,
18736 _("string table"));
18737 strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
18738 }
18739 }
18740 }
18741 saved_filedata = filedata;
18742 }
18743
18744 if (symtab == NULL || strtab == NULL)
18745 return NULL;
18746
18747 /* Find a symbol whose value matches offset. */
18748 for (sym = symtab; sym < symtab + nsyms; sym ++)
18749 if (sym->st_value == offset)
18750 {
18751 if (sym->st_name >= strtablen)
18752 /* Huh ? This should not happen. */
18753 continue;
18754
18755 if (strtab[sym->st_name] == 0)
18756 continue;
18757
18758 /* The AArch64 and ARM architectures define mapping symbols
18759 (eg $d, $x, $t) which we want to ignore. */
18760 if (strtab[sym->st_name] == '$'
18761 && strtab[sym->st_name + 1] != 0
18762 && strtab[sym->st_name + 2] == 0)
18763 continue;
18764
18765 if (is_open_attr)
18766 {
18767 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
18768 and FILE or OBJECT symbols over NOTYPE symbols. We skip
18769 FUNC symbols entirely. */
18770 switch (ELF_ST_TYPE (sym->st_info))
18771 {
18772 case STT_OBJECT:
18773 case STT_FILE:
18774 saved_sym = sym;
18775 if (sym->st_size)
18776 {
18777 /* If the symbol has a size associated
18778 with it then we can stop searching. */
18779 sym = symtab + nsyms;
18780 }
18781 continue;
18782
18783 case STT_FUNC:
18784 /* Ignore function symbols. */
18785 continue;
18786
18787 default:
18788 break;
18789 }
18790
18791 switch (ELF_ST_BIND (sym->st_info))
18792 {
18793 case STB_GLOBAL:
18794 if (saved_sym == NULL
18795 || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
18796 saved_sym = sym;
18797 break;
18798
18799 case STB_LOCAL:
18800 if (saved_sym == NULL)
18801 saved_sym = sym;
18802 break;
18803
18804 default:
18805 break;
18806 }
18807 }
18808 else
18809 {
18810 if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
18811 continue;
18812
18813 saved_sym = sym;
18814 break;
18815 }
18816 }
18817
18818 if (saved_sym && pname)
18819 * pname = strtab + saved_sym->st_name;
18820
18821 return saved_sym;
18822 }
18823
18824 /* Returns true iff addr1 and addr2 are in the same section. */
18825
18826 static bfd_boolean
same_section(Filedata * filedata,unsigned long addr1,unsigned long addr2)18827 same_section (Filedata * filedata, unsigned long addr1, unsigned long addr2)
18828 {
18829 Elf_Internal_Shdr * a1;
18830 Elf_Internal_Shdr * a2;
18831
18832 a1 = find_section_by_address (filedata, addr1);
18833 a2 = find_section_by_address (filedata, addr2);
18834
18835 return a1 == a2 && a1 != NULL;
18836 }
18837
18838 static bfd_boolean
print_gnu_build_attribute_description(Elf_Internal_Note * pnote,Filedata * filedata)18839 print_gnu_build_attribute_description (Elf_Internal_Note * pnote,
18840 Filedata * filedata)
18841 {
18842 static unsigned long global_offset = 0;
18843 static unsigned long global_end = 0;
18844 static unsigned long func_offset = 0;
18845 static unsigned long func_end = 0;
18846
18847 Elf_Internal_Sym * sym;
18848 const char * name;
18849 unsigned long start;
18850 unsigned long end;
18851 bfd_boolean is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
18852
18853 switch (pnote->descsz)
18854 {
18855 case 0:
18856 /* A zero-length description means that the range of
18857 the previous note of the same type should be used. */
18858 if (is_open_attr)
18859 {
18860 if (global_end > global_offset)
18861 printf (_(" Applies to region from %#lx to %#lx\n"),
18862 global_offset, global_end);
18863 else
18864 printf (_(" Applies to region from %#lx\n"), global_offset);
18865 }
18866 else
18867 {
18868 if (func_end > func_offset)
18869 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset, func_end);
18870 else
18871 printf (_(" Applies to region from %#lx\n"), func_offset);
18872 }
18873 return TRUE;
18874
18875 case 4:
18876 start = byte_get ((unsigned char *) pnote->descdata, 4);
18877 end = 0;
18878 break;
18879
18880 case 8:
18881 if (is_32bit_elf)
18882 {
18883 /* FIXME: We should check that version 3+ notes are being used here... */
18884 start = byte_get ((unsigned char *) pnote->descdata, 4);
18885 end = byte_get ((unsigned char *) pnote->descdata + 4, 4);
18886 }
18887 else
18888 {
18889 start = byte_get ((unsigned char *) pnote->descdata, 8);
18890 end = 0;
18891 }
18892 break;
18893
18894 case 16:
18895 start = byte_get ((unsigned char *) pnote->descdata, 8);
18896 end = byte_get ((unsigned char *) pnote->descdata + 8, 8);
18897 break;
18898
18899 default:
18900 error (_(" <invalid description size: %lx>\n"), pnote->descsz);
18901 printf (_(" <invalid descsz>"));
18902 return FALSE;
18903 }
18904
18905 name = NULL;
18906 sym = get_symbol_for_build_attribute (filedata, start, is_open_attr, & name);
18907 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
18908 in order to avoid them being confused with the start address of the
18909 first function in the file... */
18910 if (sym == NULL && is_open_attr)
18911 sym = get_symbol_for_build_attribute (filedata, start + 2, is_open_attr,
18912 & name);
18913
18914 if (end == 0 && sym != NULL && sym->st_size > 0)
18915 end = start + sym->st_size;
18916
18917 if (is_open_attr)
18918 {
18919 /* FIXME: Need to properly allow for section alignment.
18920 16 is just the alignment used on x86_64. */
18921 if (global_end > 0
18922 && start > BFD_ALIGN (global_end, 16)
18923 /* Build notes are not guaranteed to be organised in order of
18924 increasing address, but we should find the all of the notes
18925 for one section in the same place. */
18926 && same_section (filedata, start, global_end))
18927 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
18928 global_end + 1, start - 1);
18929
18930 printf (_(" Applies to region from %#lx"), start);
18931 global_offset = start;
18932
18933 if (end)
18934 {
18935 printf (_(" to %#lx"), end);
18936 global_end = end;
18937 }
18938 }
18939 else
18940 {
18941 printf (_(" Applies to region from %#lx"), start);
18942 func_offset = start;
18943
18944 if (end)
18945 {
18946 printf (_(" to %#lx"), end);
18947 func_end = end;
18948 }
18949 }
18950
18951 if (sym && name)
18952 printf (_(" (%s)"), name);
18953
18954 printf ("\n");
18955 return TRUE;
18956 }
18957
18958 static bfd_boolean
print_gnu_build_attribute_name(Elf_Internal_Note * pnote)18959 print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
18960 {
18961 static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
18962 static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
18963 static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
18964 char name_type;
18965 char name_attribute;
18966 const char * expected_types;
18967 const char * name = pnote->namedata;
18968 const char * text;
18969 signed int left;
18970
18971 if (name == NULL || pnote->namesz < 2)
18972 {
18973 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
18974 print_symbol (-20, _(" <corrupt name>"));
18975 return FALSE;
18976 }
18977
18978 if (do_wide)
18979 left = 28;
18980 else
18981 left = 20;
18982
18983 /* Version 2 of the spec adds a "GA" prefix to the name field. */
18984 if (name[0] == 'G' && name[1] == 'A')
18985 {
18986 if (pnote->namesz < 4)
18987 {
18988 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
18989 print_symbol (-20, _(" <corrupt name>"));
18990 return FALSE;
18991 }
18992
18993 printf ("GA");
18994 name += 2;
18995 left -= 2;
18996 }
18997
18998 switch ((name_type = * name))
18999 {
19000 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
19001 case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
19002 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
19003 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
19004 printf ("%c", * name);
19005 left --;
19006 break;
19007 default:
19008 error (_("unrecognised attribute type in name field: %d\n"), name_type);
19009 print_symbol (-20, _("<unknown name type>"));
19010 return FALSE;
19011 }
19012
19013 ++ name;
19014 text = NULL;
19015
19016 switch ((name_attribute = * name))
19017 {
19018 case GNU_BUILD_ATTRIBUTE_VERSION:
19019 text = _("<version>");
19020 expected_types = string_expected;
19021 ++ name;
19022 break;
19023 case GNU_BUILD_ATTRIBUTE_STACK_PROT:
19024 text = _("<stack prot>");
19025 expected_types = "!+*";
19026 ++ name;
19027 break;
19028 case GNU_BUILD_ATTRIBUTE_RELRO:
19029 text = _("<relro>");
19030 expected_types = bool_expected;
19031 ++ name;
19032 break;
19033 case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
19034 text = _("<stack size>");
19035 expected_types = number_expected;
19036 ++ name;
19037 break;
19038 case GNU_BUILD_ATTRIBUTE_TOOL:
19039 text = _("<tool>");
19040 expected_types = string_expected;
19041 ++ name;
19042 break;
19043 case GNU_BUILD_ATTRIBUTE_ABI:
19044 text = _("<ABI>");
19045 expected_types = "$*";
19046 ++ name;
19047 break;
19048 case GNU_BUILD_ATTRIBUTE_PIC:
19049 text = _("<PIC>");
19050 expected_types = number_expected;
19051 ++ name;
19052 break;
19053 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
19054 text = _("<short enum>");
19055 expected_types = bool_expected;
19056 ++ name;
19057 break;
19058 default:
19059 if (ISPRINT (* name))
19060 {
19061 int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
19062
19063 if (len > left && ! do_wide)
19064 len = left;
19065 printf ("%.*s:", len, name);
19066 left -= len;
19067 name += len;
19068 }
19069 else
19070 {
19071 static char tmpbuf [128];
19072
19073 error (_("unrecognised byte in name field: %d\n"), * name);
19074 sprintf (tmpbuf, _("<unknown:_%d>"), * name);
19075 text = tmpbuf;
19076 name ++;
19077 }
19078 expected_types = "*$!+";
19079 break;
19080 }
19081
19082 if (text)
19083 left -= printf ("%s", text);
19084
19085 if (strchr (expected_types, name_type) == NULL)
19086 warn (_("attribute does not have an expected type (%c)\n"), name_type);
19087
19088 if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
19089 {
19090 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
19091 (unsigned long) pnote->namesz,
19092 (long) (name - pnote->namedata));
19093 return FALSE;
19094 }
19095
19096 if (left < 1 && ! do_wide)
19097 return TRUE;
19098
19099 switch (name_type)
19100 {
19101 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
19102 {
19103 unsigned int bytes;
19104 unsigned long long val = 0;
19105 unsigned int shift = 0;
19106 char * decoded = NULL;
19107
19108 bytes = pnote->namesz - (name - pnote->namedata);
19109 if (bytes > 0)
19110 /* The -1 is because the name field is always 0 terminated, and we
19111 want to be able to ensure that the shift in the while loop below
19112 will not overflow. */
19113 -- bytes;
19114
19115 if (bytes > sizeof (val))
19116 {
19117 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
19118 bytes);
19119 bytes = sizeof (val);
19120 }
19121 /* We do not bother to warn if bytes == 0 as this can
19122 happen with some early versions of the gcc plugin. */
19123
19124 while (bytes --)
19125 {
19126 unsigned long byte = (* name ++) & 0xff;
19127
19128 val |= byte << shift;
19129 shift += 8;
19130 }
19131
19132 switch (name_attribute)
19133 {
19134 case GNU_BUILD_ATTRIBUTE_PIC:
19135 switch (val)
19136 {
19137 case 0: decoded = "static"; break;
19138 case 1: decoded = "pic"; break;
19139 case 2: decoded = "PIC"; break;
19140 case 3: decoded = "pie"; break;
19141 case 4: decoded = "PIE"; break;
19142 default: break;
19143 }
19144 break;
19145 case GNU_BUILD_ATTRIBUTE_STACK_PROT:
19146 switch (val)
19147 {
19148 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
19149 case 0: decoded = "off"; break;
19150 case 1: decoded = "on"; break;
19151 case 2: decoded = "all"; break;
19152 case 3: decoded = "strong"; break;
19153 case 4: decoded = "explicit"; break;
19154 default: break;
19155 }
19156 break;
19157 default:
19158 break;
19159 }
19160
19161 if (decoded != NULL)
19162 {
19163 print_symbol (-left, decoded);
19164 left = 0;
19165 }
19166 else if (val == 0)
19167 {
19168 printf ("0x0");
19169 left -= 3;
19170 }
19171 else
19172 {
19173 if (do_wide)
19174 left -= printf ("0x%llx", val);
19175 else
19176 left -= printf ("0x%-.*llx", left, val);
19177 }
19178 }
19179 break;
19180 case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
19181 left -= print_symbol (- left, name);
19182 break;
19183 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
19184 left -= print_symbol (- left, "true");
19185 break;
19186 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
19187 left -= print_symbol (- left, "false");
19188 break;
19189 }
19190
19191 if (do_wide && left > 0)
19192 printf ("%-*s", left, " ");
19193
19194 return TRUE;
19195 }
19196
19197 /* Note that by the ELF standard, the name field is already null byte
19198 terminated, and namesz includes the terminating null byte.
19199 I.E. the value of namesz for the name "FSF" is 4.
19200
19201 If the value of namesz is zero, there is no name present. */
19202
19203 static bfd_boolean
process_note(Elf_Internal_Note * pnote,Filedata * filedata)19204 process_note (Elf_Internal_Note * pnote,
19205 Filedata * filedata)
19206 {
19207 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
19208 const char * nt;
19209
19210 if (pnote->namesz == 0)
19211 /* If there is no note name, then use the default set of
19212 note type strings. */
19213 nt = get_note_type (filedata, pnote->type);
19214
19215 else if (const_strneq (pnote->namedata, "GNU"))
19216 /* GNU-specific object file notes. */
19217 nt = get_gnu_elf_note_type (pnote->type);
19218
19219 else if (const_strneq (pnote->namedata, "FreeBSD"))
19220 /* FreeBSD-specific core file notes. */
19221 nt = get_freebsd_elfcore_note_type (filedata, pnote->type);
19222
19223 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
19224 /* NetBSD-specific core file notes. */
19225 nt = get_netbsd_elfcore_note_type (filedata, pnote->type);
19226
19227 else if (const_strneq (pnote->namedata, "NetBSD"))
19228 /* NetBSD-specific core file notes. */
19229 return process_netbsd_elf_note (pnote);
19230
19231 else if (const_strneq (pnote->namedata, "PaX"))
19232 /* NetBSD-specific core file notes. */
19233 return process_netbsd_elf_note (pnote);
19234
19235 else if (strneq (pnote->namedata, "SPU/", 4))
19236 {
19237 /* SPU-specific core file notes. */
19238 nt = pnote->namedata + 4;
19239 name = "SPU";
19240 }
19241
19242 else if (const_strneq (pnote->namedata, "IPF/VMS"))
19243 /* VMS/ia64-specific file notes. */
19244 nt = get_ia64_vms_note_type (pnote->type);
19245
19246 else if (const_strneq (pnote->namedata, "stapsdt"))
19247 nt = get_stapsdt_note_type (pnote->type);
19248
19249 else
19250 /* Don't recognize this note name; just use the default set of
19251 note type strings. */
19252 nt = get_note_type (filedata, pnote->type);
19253
19254 printf (" ");
19255
19256 if (((const_strneq (pnote->namedata, "GA")
19257 && strchr ("*$!+", pnote->namedata[2]) != NULL)
19258 || strchr ("*$!+", pnote->namedata[0]) != NULL)
19259 && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
19260 || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
19261 print_gnu_build_attribute_name (pnote);
19262 else
19263 print_symbol (-20, name);
19264
19265 if (do_wide)
19266 printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
19267 else
19268 printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
19269
19270 if (const_strneq (pnote->namedata, "IPF/VMS"))
19271 return print_ia64_vms_note (pnote);
19272 else if (const_strneq (pnote->namedata, "GNU"))
19273 return print_gnu_note (filedata, pnote);
19274 else if (const_strneq (pnote->namedata, "stapsdt"))
19275 return print_stapsdt_note (pnote);
19276 else if (const_strneq (pnote->namedata, "CORE"))
19277 return print_core_note (pnote);
19278 else if (((const_strneq (pnote->namedata, "GA")
19279 && strchr ("*$!+", pnote->namedata[2]) != NULL)
19280 || strchr ("*$!+", pnote->namedata[0]) != NULL)
19281 && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
19282 || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
19283 return print_gnu_build_attribute_description (pnote, filedata);
19284
19285 if (pnote->descsz)
19286 {
19287 unsigned long i;
19288
19289 printf (_(" description data: "));
19290 for (i = 0; i < pnote->descsz; i++)
19291 printf ("%02x ", pnote->descdata[i] & 0xff);
19292 if (!do_wide)
19293 printf ("\n");
19294 }
19295
19296 if (do_wide)
19297 printf ("\n");
19298
19299 return TRUE;
19300 }
19301
19302 static bfd_boolean
process_notes_at(Filedata * filedata,Elf_Internal_Shdr * section,bfd_vma offset,bfd_vma length,bfd_vma align)19303 process_notes_at (Filedata * filedata,
19304 Elf_Internal_Shdr * section,
19305 bfd_vma offset,
19306 bfd_vma length,
19307 bfd_vma align)
19308 {
19309 Elf_External_Note * pnotes;
19310 Elf_External_Note * external;
19311 char * end;
19312 bfd_boolean res = TRUE;
19313
19314 if (length <= 0)
19315 return FALSE;
19316
19317 if (section)
19318 {
19319 pnotes = (Elf_External_Note *) get_section_contents (section, filedata);
19320 if (pnotes)
19321 {
19322 if (! apply_relocations (filedata, section, (unsigned char *) pnotes, length, NULL, NULL))
19323 return FALSE;
19324 }
19325 }
19326 else
19327 pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
19328 _("notes"));
19329
19330 if (pnotes == NULL)
19331 return FALSE;
19332
19333 external = pnotes;
19334
19335 if (section)
19336 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata, section));
19337 else
19338 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19339 (unsigned long) offset, (unsigned long) length);
19340
19341 /* NB: Some note sections may have alignment value of 0 or 1. gABI
19342 specifies that notes should be aligned to 4 bytes in 32-bit
19343 objects and to 8 bytes in 64-bit objects. As a Linux extension,
19344 we also support 4 byte alignment in 64-bit objects. If section
19345 alignment is less than 4, we treate alignment as 4 bytes. */
19346 if (align < 4)
19347 align = 4;
19348 else if (align != 4 && align != 8)
19349 {
19350 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19351 (long) align);
19352 free (pnotes);
19353 return FALSE;
19354 }
19355
19356 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
19357
19358 end = (char *) pnotes + length;
19359 while ((char *) external < end)
19360 {
19361 Elf_Internal_Note inote;
19362 size_t min_notesz;
19363 char * next;
19364 char * temp = NULL;
19365 size_t data_remaining = end - (char *) external;
19366
19367 if (!is_ia64_vms (filedata))
19368 {
19369 /* PR binutils/15191
19370 Make sure that there is enough data to read. */
19371 min_notesz = offsetof (Elf_External_Note, name);
19372 if (data_remaining < min_notesz)
19373 {
19374 warn (ngettext ("Corrupt note: only %ld byte remains, "
19375 "not enough for a full note\n",
19376 "Corrupt note: only %ld bytes remain, "
19377 "not enough for a full note\n",
19378 data_remaining),
19379 (long) data_remaining);
19380 break;
19381 }
19382 data_remaining -= min_notesz;
19383
19384 inote.type = BYTE_GET (external->type);
19385 inote.namesz = BYTE_GET (external->namesz);
19386 inote.namedata = external->name;
19387 inote.descsz = BYTE_GET (external->descsz);
19388 inote.descdata = ((char *) external
19389 + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
19390 inote.descpos = offset + (inote.descdata - (char *) pnotes);
19391 next = ((char *) external
19392 + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
19393 }
19394 else
19395 {
19396 Elf64_External_VMS_Note *vms_external;
19397
19398 /* PR binutils/15191
19399 Make sure that there is enough data to read. */
19400 min_notesz = offsetof (Elf64_External_VMS_Note, name);
19401 if (data_remaining < min_notesz)
19402 {
19403 warn (ngettext ("Corrupt note: only %ld byte remains, "
19404 "not enough for a full note\n",
19405 "Corrupt note: only %ld bytes remain, "
19406 "not enough for a full note\n",
19407 data_remaining),
19408 (long) data_remaining);
19409 break;
19410 }
19411 data_remaining -= min_notesz;
19412
19413 vms_external = (Elf64_External_VMS_Note *) external;
19414 inote.type = BYTE_GET (vms_external->type);
19415 inote.namesz = BYTE_GET (vms_external->namesz);
19416 inote.namedata = vms_external->name;
19417 inote.descsz = BYTE_GET (vms_external->descsz);
19418 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
19419 inote.descpos = offset + (inote.descdata - (char *) pnotes);
19420 next = inote.descdata + align_power (inote.descsz, 3);
19421 }
19422
19423 /* PR 17531: file: 3443835e. */
19424 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
19425 if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
19426 || (size_t) (inote.descdata - inote.namedata) > data_remaining
19427 || (size_t) (next - inote.descdata) < inote.descsz
19428 || ((size_t) (next - inote.descdata)
19429 > data_remaining - (size_t) (inote.descdata - inote.namedata)))
19430 {
19431 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
19432 (unsigned long) ((char *) external - (char *) pnotes));
19433 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
19434 inote.type, inote.namesz, inote.descsz, (int) align);
19435 break;
19436 }
19437
19438 external = (Elf_External_Note *) next;
19439
19440 /* Verify that name is null terminated. It appears that at least
19441 one version of Linux (RedHat 6.0) generates corefiles that don't
19442 comply with the ELF spec by failing to include the null byte in
19443 namesz. */
19444 if (inote.namesz > 0 && inote.namedata[inote.namesz - 1] != '\0')
19445 {
19446 if ((size_t) (inote.descdata - inote.namedata) == inote.namesz)
19447 {
19448 temp = (char *) malloc (inote.namesz + 1);
19449 if (temp == NULL)
19450 {
19451 error (_("Out of memory allocating space for inote name\n"));
19452 res = FALSE;
19453 break;
19454 }
19455
19456 memcpy (temp, inote.namedata, inote.namesz);
19457 inote.namedata = temp;
19458 }
19459 inote.namedata[inote.namesz] = 0;
19460 }
19461
19462 if (! process_note (& inote, filedata))
19463 res = FALSE;
19464
19465 if (temp != NULL)
19466 {
19467 free (temp);
19468 temp = NULL;
19469 }
19470 }
19471
19472 free (pnotes);
19473
19474 return res;
19475 }
19476
19477 static bfd_boolean
process_corefile_note_segments(Filedata * filedata)19478 process_corefile_note_segments (Filedata * filedata)
19479 {
19480 Elf_Internal_Phdr * segment;
19481 unsigned int i;
19482 bfd_boolean res = TRUE;
19483
19484 if (! get_program_headers (filedata))
19485 return TRUE;
19486
19487 for (i = 0, segment = filedata->program_headers;
19488 i < filedata->file_header.e_phnum;
19489 i++, segment++)
19490 {
19491 if (segment->p_type == PT_NOTE)
19492 if (! process_notes_at (filedata, NULL,
19493 (bfd_vma) segment->p_offset,
19494 (bfd_vma) segment->p_filesz,
19495 (bfd_vma) segment->p_align))
19496 res = FALSE;
19497 }
19498
19499 return res;
19500 }
19501
19502 static bfd_boolean
process_v850_notes(Filedata * filedata,bfd_vma offset,bfd_vma length)19503 process_v850_notes (Filedata * filedata, bfd_vma offset, bfd_vma length)
19504 {
19505 Elf_External_Note * pnotes;
19506 Elf_External_Note * external;
19507 char * end;
19508 bfd_boolean res = TRUE;
19509
19510 if (length <= 0)
19511 return FALSE;
19512
19513 pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
19514 _("v850 notes"));
19515 if (pnotes == NULL)
19516 return FALSE;
19517
19518 external = pnotes;
19519 end = (char*) pnotes + length;
19520
19521 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
19522 (unsigned long) offset, (unsigned long) length);
19523
19524 while ((char *) external + sizeof (Elf_External_Note) < end)
19525 {
19526 Elf_External_Note * next;
19527 Elf_Internal_Note inote;
19528
19529 inote.type = BYTE_GET (external->type);
19530 inote.namesz = BYTE_GET (external->namesz);
19531 inote.namedata = external->name;
19532 inote.descsz = BYTE_GET (external->descsz);
19533 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
19534 inote.descpos = offset + (inote.descdata - (char *) pnotes);
19535
19536 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
19537 {
19538 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
19539 inote.descdata = inote.namedata;
19540 inote.namesz = 0;
19541 }
19542
19543 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
19544
19545 if ( ((char *) next > end)
19546 || ((char *) next < (char *) pnotes))
19547 {
19548 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19549 (unsigned long) ((char *) external - (char *) pnotes));
19550 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19551 inote.type, inote.namesz, inote.descsz);
19552 break;
19553 }
19554
19555 external = next;
19556
19557 /* Prevent out-of-bounds indexing. */
19558 if ( inote.namedata + inote.namesz > end
19559 || inote.namedata + inote.namesz < inote.namedata)
19560 {
19561 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19562 (unsigned long) ((char *) external - (char *) pnotes));
19563 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19564 inote.type, inote.namesz, inote.descsz);
19565 break;
19566 }
19567
19568 printf (" %s: ", get_v850_elf_note_type (inote.type));
19569
19570 if (! print_v850_note (& inote))
19571 {
19572 res = FALSE;
19573 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19574 inote.namesz, inote.descsz);
19575 }
19576 }
19577
19578 free (pnotes);
19579
19580 return res;
19581 }
19582
19583 static bfd_boolean
process_note_sections(Filedata * filedata)19584 process_note_sections (Filedata * filedata)
19585 {
19586 Elf_Internal_Shdr * section;
19587 unsigned long i;
19588 unsigned int n = 0;
19589 bfd_boolean res = TRUE;
19590
19591 for (i = 0, section = filedata->section_headers;
19592 i < filedata->file_header.e_shnum && section != NULL;
19593 i++, section++)
19594 {
19595 if (section->sh_type == SHT_NOTE)
19596 {
19597 if (! process_notes_at (filedata, section,
19598 (bfd_vma) section->sh_offset,
19599 (bfd_vma) section->sh_size,
19600 (bfd_vma) section->sh_addralign))
19601 res = FALSE;
19602 n++;
19603 }
19604
19605 if (( filedata->file_header.e_machine == EM_V800
19606 || filedata->file_header.e_machine == EM_V850
19607 || filedata->file_header.e_machine == EM_CYGNUS_V850)
19608 && section->sh_type == SHT_RENESAS_INFO)
19609 {
19610 if (! process_v850_notes (filedata,
19611 (bfd_vma) section->sh_offset,
19612 (bfd_vma) section->sh_size))
19613 res = FALSE;
19614 n++;
19615 }
19616 }
19617
19618 if (n == 0)
19619 /* Try processing NOTE segments instead. */
19620 return process_corefile_note_segments (filedata);
19621
19622 return res;
19623 }
19624
19625 static bfd_boolean
process_notes(Filedata * filedata)19626 process_notes (Filedata * filedata)
19627 {
19628 /* If we have not been asked to display the notes then do nothing. */
19629 if (! do_notes)
19630 return TRUE;
19631
19632 if (filedata->file_header.e_type != ET_CORE)
19633 return process_note_sections (filedata);
19634
19635 /* No program headers means no NOTE segment. */
19636 if (filedata->file_header.e_phnum > 0)
19637 return process_corefile_note_segments (filedata);
19638
19639 printf (_("No note segments present in the core file.\n"));
19640 return TRUE;
19641 }
19642
19643 static unsigned char *
display_public_gnu_attributes(unsigned char * start,const unsigned char * const end)19644 display_public_gnu_attributes (unsigned char * start,
19645 const unsigned char * const end)
19646 {
19647 printf (_(" Unknown GNU attribute: %s\n"), start);
19648
19649 start += strnlen ((char *) start, end - start);
19650 display_raw_attribute (start, end);
19651
19652 return (unsigned char *) end;
19653 }
19654
19655 static unsigned char *
display_generic_attribute(unsigned char * start,unsigned int tag,const unsigned char * const end)19656 display_generic_attribute (unsigned char * start,
19657 unsigned int tag,
19658 const unsigned char * const end)
19659 {
19660 if (tag == 0)
19661 return (unsigned char *) end;
19662
19663 return display_tag_value (tag, start, end);
19664 }
19665
19666 static bfd_boolean
process_arch_specific(Filedata * filedata)19667 process_arch_specific (Filedata * filedata)
19668 {
19669 if (! do_arch)
19670 return TRUE;
19671
19672 switch (filedata->file_header.e_machine)
19673 {
19674 case EM_ARC:
19675 case EM_ARC_COMPACT:
19676 case EM_ARC_COMPACT2:
19677 return process_attributes (filedata, "ARC", SHT_ARC_ATTRIBUTES,
19678 display_arc_attribute,
19679 display_generic_attribute);
19680 case EM_ARM:
19681 return process_attributes (filedata, "aeabi", SHT_ARM_ATTRIBUTES,
19682 display_arm_attribute,
19683 display_generic_attribute);
19684
19685 case EM_MIPS:
19686 case EM_MIPS_RS3_LE:
19687 return process_mips_specific (filedata);
19688
19689 case EM_MSP430:
19690 return process_attributes (filedata, "mspabi", SHT_MSP430_ATTRIBUTES,
19691 display_msp430x_attribute,
19692 display_msp430_gnu_attribute);
19693
19694 case EM_RISCV:
19695 return process_attributes (filedata, "riscv", SHT_RISCV_ATTRIBUTES,
19696 display_riscv_attribute,
19697 display_generic_attribute);
19698
19699 case EM_NDS32:
19700 return process_nds32_specific (filedata);
19701
19702 case EM_PPC:
19703 case EM_PPC64:
19704 return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
19705 display_power_gnu_attribute);
19706
19707 case EM_S390:
19708 case EM_S390_OLD:
19709 return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
19710 display_s390_gnu_attribute);
19711
19712 case EM_SPARC:
19713 case EM_SPARC32PLUS:
19714 case EM_SPARCV9:
19715 return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
19716 display_sparc_gnu_attribute);
19717
19718 case EM_TI_C6000:
19719 return process_attributes (filedata, "c6xabi", SHT_C6000_ATTRIBUTES,
19720 display_tic6x_attribute,
19721 display_generic_attribute);
19722
19723 default:
19724 return process_attributes (filedata, "gnu", SHT_GNU_ATTRIBUTES,
19725 display_public_gnu_attributes,
19726 display_generic_attribute);
19727 }
19728 }
19729
19730 static bfd_boolean
get_file_header(Filedata * filedata)19731 get_file_header (Filedata * filedata)
19732 {
19733 /* Read in the identity array. */
19734 if (fread (filedata->file_header.e_ident, EI_NIDENT, 1, filedata->handle) != 1)
19735 return FALSE;
19736
19737 /* Determine how to read the rest of the header. */
19738 switch (filedata->file_header.e_ident[EI_DATA])
19739 {
19740 default:
19741 case ELFDATANONE:
19742 case ELFDATA2LSB:
19743 byte_get = byte_get_little_endian;
19744 byte_put = byte_put_little_endian;
19745 break;
19746 case ELFDATA2MSB:
19747 byte_get = byte_get_big_endian;
19748 byte_put = byte_put_big_endian;
19749 break;
19750 }
19751
19752 /* For now we only support 32 bit and 64 bit ELF files. */
19753 is_32bit_elf = (filedata->file_header.e_ident[EI_CLASS] != ELFCLASS64);
19754
19755 /* Read in the rest of the header. */
19756 if (is_32bit_elf)
19757 {
19758 Elf32_External_Ehdr ehdr32;
19759
19760 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, filedata->handle) != 1)
19761 return FALSE;
19762
19763 filedata->file_header.e_type = BYTE_GET (ehdr32.e_type);
19764 filedata->file_header.e_machine = BYTE_GET (ehdr32.e_machine);
19765 filedata->file_header.e_version = BYTE_GET (ehdr32.e_version);
19766 filedata->file_header.e_entry = BYTE_GET (ehdr32.e_entry);
19767 filedata->file_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
19768 filedata->file_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
19769 filedata->file_header.e_flags = BYTE_GET (ehdr32.e_flags);
19770 filedata->file_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
19771 filedata->file_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
19772 filedata->file_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
19773 filedata->file_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
19774 filedata->file_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
19775 filedata->file_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
19776 }
19777 else
19778 {
19779 Elf64_External_Ehdr ehdr64;
19780
19781 /* If we have been compiled with sizeof (bfd_vma) == 4, then
19782 we will not be able to cope with the 64bit data found in
19783 64 ELF files. Detect this now and abort before we start
19784 overwriting things. */
19785 if (sizeof (bfd_vma) < 8)
19786 {
19787 error (_("This instance of readelf has been built without support for a\n\
19788 64 bit data type and so it cannot read 64 bit ELF files.\n"));
19789 return FALSE;
19790 }
19791
19792 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, filedata->handle) != 1)
19793 return FALSE;
19794
19795 filedata->file_header.e_type = BYTE_GET (ehdr64.e_type);
19796 filedata->file_header.e_machine = BYTE_GET (ehdr64.e_machine);
19797 filedata->file_header.e_version = BYTE_GET (ehdr64.e_version);
19798 filedata->file_header.e_entry = BYTE_GET (ehdr64.e_entry);
19799 filedata->file_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
19800 filedata->file_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
19801 filedata->file_header.e_flags = BYTE_GET (ehdr64.e_flags);
19802 filedata->file_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
19803 filedata->file_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
19804 filedata->file_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
19805 filedata->file_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
19806 filedata->file_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
19807 filedata->file_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
19808 }
19809
19810 if (filedata->file_header.e_shoff)
19811 {
19812 /* There may be some extensions in the first section header. Don't
19813 bomb if we can't read it. */
19814 if (is_32bit_elf)
19815 get_32bit_section_headers (filedata, TRUE);
19816 else
19817 get_64bit_section_headers (filedata, TRUE);
19818 }
19819
19820 return TRUE;
19821 }
19822
19823 static void
close_file(Filedata * filedata)19824 close_file (Filedata * filedata)
19825 {
19826 if (filedata)
19827 {
19828 if (filedata->handle)
19829 fclose (filedata->handle);
19830 free (filedata);
19831 }
19832 }
19833
19834 void
close_debug_file(void * data)19835 close_debug_file (void * data)
19836 {
19837 close_file ((Filedata *) data);
19838 }
19839
19840 static Filedata *
open_file(const char * pathname)19841 open_file (const char * pathname)
19842 {
19843 struct stat statbuf;
19844 Filedata * filedata = NULL;
19845
19846 if (stat (pathname, & statbuf) < 0
19847 || ! S_ISREG (statbuf.st_mode))
19848 goto fail;
19849
19850 filedata = calloc (1, sizeof * filedata);
19851 if (filedata == NULL)
19852 goto fail;
19853
19854 filedata->handle = fopen (pathname, "rb");
19855 if (filedata->handle == NULL)
19856 goto fail;
19857
19858 filedata->file_size = (bfd_size_type) statbuf.st_size;
19859 filedata->file_name = pathname;
19860
19861 if (! get_file_header (filedata))
19862 goto fail;
19863
19864 if (filedata->file_header.e_shoff)
19865 {
19866 bfd_boolean res;
19867
19868 /* Read the section headers again, this time for real. */
19869 if (is_32bit_elf)
19870 res = get_32bit_section_headers (filedata, FALSE);
19871 else
19872 res = get_64bit_section_headers (filedata, FALSE);
19873
19874 if (!res)
19875 goto fail;
19876 }
19877
19878 return filedata;
19879
19880 fail:
19881 if (filedata)
19882 {
19883 if (filedata->handle)
19884 fclose (filedata->handle);
19885 free (filedata);
19886 }
19887 return NULL;
19888 }
19889
19890 void *
open_debug_file(const char * pathname)19891 open_debug_file (const char * pathname)
19892 {
19893 return open_file (pathname);
19894 }
19895
19896 /* Process one ELF object file according to the command line options.
19897 This file may actually be stored in an archive. The file is
19898 positioned at the start of the ELF object. Returns TRUE if no
19899 problems were encountered, FALSE otherwise. */
19900
19901 static bfd_boolean
process_object(Filedata * filedata)19902 process_object (Filedata * filedata)
19903 {
19904 bfd_boolean have_separate_files;
19905 unsigned int i;
19906 bfd_boolean res = TRUE;
19907
19908 if (! get_file_header (filedata))
19909 {
19910 error (_("%s: Failed to read file header\n"), filedata->file_name);
19911 return FALSE;
19912 }
19913
19914 /* Initialise per file variables. */
19915 for (i = ARRAY_SIZE (version_info); i--;)
19916 version_info[i] = 0;
19917
19918 for (i = ARRAY_SIZE (dynamic_info); i--;)
19919 dynamic_info[i] = 0;
19920 dynamic_info_DT_GNU_HASH = 0;
19921 dynamic_info_DT_MIPS_XHASH = 0;
19922
19923 /* Process the file. */
19924 if (show_name)
19925 printf (_("\nFile: %s\n"), filedata->file_name);
19926
19927 /* Initialise the dump_sects array from the cmdline_dump_sects array.
19928 Note we do this even if cmdline_dump_sects is empty because we
19929 must make sure that the dump_sets array is zeroed out before each
19930 object file is processed. */
19931 if (filedata->num_dump_sects > cmdline.num_dump_sects)
19932 memset (filedata->dump_sects, 0, filedata->num_dump_sects * sizeof (* filedata->dump_sects));
19933
19934 if (cmdline.num_dump_sects > 0)
19935 {
19936 if (filedata->num_dump_sects == 0)
19937 /* A sneaky way of allocating the dump_sects array. */
19938 request_dump_bynumber (filedata, cmdline.num_dump_sects, 0);
19939
19940 assert (filedata->num_dump_sects >= cmdline.num_dump_sects);
19941 memcpy (filedata->dump_sects, cmdline.dump_sects,
19942 cmdline.num_dump_sects * sizeof (* filedata->dump_sects));
19943 }
19944
19945 if (! process_file_header (filedata))
19946 return FALSE;
19947
19948 if (! process_section_headers (filedata))
19949 {
19950 /* Without loaded section headers we cannot process lots of things. */
19951 do_unwind = do_version = do_dump = do_arch = FALSE;
19952
19953 if (! do_using_dynamic)
19954 do_syms = do_dyn_syms = do_reloc = FALSE;
19955 }
19956
19957 if (! process_section_groups (filedata))
19958 /* Without loaded section groups we cannot process unwind. */
19959 do_unwind = FALSE;
19960
19961 if (process_program_headers (filedata))
19962 process_dynamic_section (filedata);
19963 else
19964 res = FALSE;
19965
19966 if (! process_relocs (filedata))
19967 res = FALSE;
19968
19969 if (! process_unwind (filedata))
19970 res = FALSE;
19971
19972 if (! process_symbol_table (filedata))
19973 res = FALSE;
19974
19975 if (! process_syminfo (filedata))
19976 res = FALSE;
19977
19978 if (! process_version_sections (filedata))
19979 res = FALSE;
19980
19981 if (filedata->file_header.e_shstrndx != SHN_UNDEF)
19982 have_separate_files = load_separate_debug_files (filedata, filedata->file_name);
19983 else
19984 have_separate_files = FALSE;
19985
19986 if (! process_section_contents (filedata))
19987 res = FALSE;
19988
19989 if (have_separate_files)
19990 {
19991 separate_info * d;
19992
19993 for (d = first_separate_info; d != NULL; d = d->next)
19994 {
19995 if (! process_section_headers (d->handle))
19996 res = FALSE;
19997 else if (! process_section_contents (d->handle))
19998 res = FALSE;
19999 }
20000
20001 /* The file handles are closed by the call to free_debug_memory() below. */
20002 }
20003
20004 if (! process_notes (filedata))
20005 res = FALSE;
20006
20007 if (! process_gnu_liblist (filedata))
20008 res = FALSE;
20009
20010 if (! process_arch_specific (filedata))
20011 res = FALSE;
20012
20013 free (filedata->program_headers);
20014 filedata->program_headers = NULL;
20015
20016 free (filedata->section_headers);
20017 filedata->section_headers = NULL;
20018
20019 free (filedata->string_table);
20020 filedata->string_table = NULL;
20021 filedata->string_table_length = 0;
20022
20023 if (filedata->dump_sects != NULL)
20024 {
20025 free (filedata->dump_sects);
20026 filedata->dump_sects = NULL;
20027 filedata->num_dump_sects = 0;
20028 }
20029
20030 if (dynamic_strings)
20031 {
20032 free (dynamic_strings);
20033 dynamic_strings = NULL;
20034 dynamic_strings_length = 0;
20035 }
20036
20037 if (dynamic_symbols)
20038 {
20039 free (dynamic_symbols);
20040 dynamic_symbols = NULL;
20041 num_dynamic_syms = 0;
20042 }
20043
20044 if (dynamic_syminfo)
20045 {
20046 free (dynamic_syminfo);
20047 dynamic_syminfo = NULL;
20048 }
20049
20050 if (dynamic_section)
20051 {
20052 free (dynamic_section);
20053 dynamic_section = NULL;
20054 }
20055
20056 if (section_headers_groups)
20057 {
20058 free (section_headers_groups);
20059 section_headers_groups = NULL;
20060 }
20061
20062 if (section_groups)
20063 {
20064 struct group_list * g;
20065 struct group_list * next;
20066
20067 for (i = 0; i < group_count; i++)
20068 {
20069 for (g = section_groups [i].root; g != NULL; g = next)
20070 {
20071 next = g->next;
20072 free (g);
20073 }
20074 }
20075
20076 free (section_groups);
20077 section_groups = NULL;
20078 }
20079
20080 free_debug_memory ();
20081
20082 return res;
20083 }
20084
20085 /* Process an ELF archive.
20086 On entry the file is positioned just after the ARMAG string.
20087 Returns TRUE upon success, FALSE otherwise. */
20088
20089 static bfd_boolean
process_archive(Filedata * filedata,bfd_boolean is_thin_archive)20090 process_archive (Filedata * filedata, bfd_boolean is_thin_archive)
20091 {
20092 struct archive_info arch;
20093 struct archive_info nested_arch;
20094 size_t got;
20095 bfd_boolean ret = TRUE;
20096
20097 show_name = TRUE;
20098
20099 /* The ARCH structure is used to hold information about this archive. */
20100 arch.file_name = NULL;
20101 arch.file = NULL;
20102 arch.index_array = NULL;
20103 arch.sym_table = NULL;
20104 arch.longnames = NULL;
20105
20106 /* The NESTED_ARCH structure is used as a single-item cache of information
20107 about a nested archive (when members of a thin archive reside within
20108 another regular archive file). */
20109 nested_arch.file_name = NULL;
20110 nested_arch.file = NULL;
20111 nested_arch.index_array = NULL;
20112 nested_arch.sym_table = NULL;
20113 nested_arch.longnames = NULL;
20114
20115 if (setup_archive (&arch, filedata->file_name, filedata->handle,
20116 is_thin_archive, do_archive_index) != 0)
20117 {
20118 ret = FALSE;
20119 goto out;
20120 }
20121
20122 if (do_archive_index)
20123 {
20124 if (arch.sym_table == NULL)
20125 error (_("%s: unable to dump the index as none was found\n"), filedata->file_name);
20126 else
20127 {
20128 unsigned long i, l;
20129 unsigned long current_pos;
20130
20131 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
20132 filedata->file_name, (unsigned long) arch.index_num, arch.sym_size);
20133
20134 current_pos = ftell (filedata->handle);
20135
20136 for (i = l = 0; i < arch.index_num; i++)
20137 {
20138 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
20139 {
20140 char * member_name;
20141
20142 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
20143
20144 if (member_name != NULL)
20145 {
20146 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
20147
20148 if (qualified_name != NULL)
20149 {
20150 printf (_("Contents of binary %s at offset "), qualified_name);
20151 (void) print_vma (arch.index_array[i], PREFIX_HEX);
20152 putchar ('\n');
20153 free (qualified_name);
20154 }
20155 }
20156 }
20157
20158 if (l >= arch.sym_size)
20159 {
20160 error (_("%s: end of the symbol table reached before the end of the index\n"),
20161 filedata->file_name);
20162 ret = FALSE;
20163 break;
20164 }
20165 /* PR 17531: file: 0b6630b2. */
20166 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
20167 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
20168 }
20169
20170 if (arch.uses_64bit_indices)
20171 l = (l + 7) & ~ 7;
20172 else
20173 l += l & 1;
20174
20175 if (l < arch.sym_size)
20176 {
20177 error (ngettext ("%s: %ld byte remains in the symbol table, "
20178 "but without corresponding entries in "
20179 "the index table\n",
20180 "%s: %ld bytes remain in the symbol table, "
20181 "but without corresponding entries in "
20182 "the index table\n",
20183 arch.sym_size - l),
20184 filedata->file_name, arch.sym_size - l);
20185 ret = FALSE;
20186 }
20187
20188 if (fseek (filedata->handle, current_pos, SEEK_SET) != 0)
20189 {
20190 error (_("%s: failed to seek back to start of object files in the archive\n"),
20191 filedata->file_name);
20192 ret = FALSE;
20193 goto out;
20194 }
20195 }
20196
20197 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
20198 && !do_segments && !do_header && !do_dump && !do_version
20199 && !do_histogram && !do_debugging && !do_arch && !do_notes
20200 && !do_section_groups && !do_dyn_syms)
20201 {
20202 ret = TRUE; /* Archive index only. */
20203 goto out;
20204 }
20205 }
20206
20207 while (1)
20208 {
20209 char * name;
20210 size_t namelen;
20211 char * qualified_name;
20212
20213 /* Read the next archive header. */
20214 if (fseek (filedata->handle, arch.next_arhdr_offset, SEEK_SET) != 0)
20215 {
20216 error (_("%s: failed to seek to next archive header\n"), arch.file_name);
20217 return FALSE;
20218 }
20219 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, filedata->handle);
20220 if (got != sizeof arch.arhdr)
20221 {
20222 if (got == 0)
20223 break;
20224 /* PR 24049 - we cannot use filedata->file_name as this will
20225 have already been freed. */
20226 error (_("%s: failed to read archive header\n"), arch.file_name);
20227
20228 ret = FALSE;
20229 break;
20230 }
20231 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
20232 {
20233 error (_("%s: did not find a valid archive header\n"), arch.file_name);
20234 ret = FALSE;
20235 break;
20236 }
20237
20238 arch.next_arhdr_offset += sizeof arch.arhdr;
20239
20240 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
20241 if (archive_file_size & 01)
20242 ++archive_file_size;
20243
20244 name = get_archive_member_name (&arch, &nested_arch);
20245 if (name == NULL)
20246 {
20247 error (_("%s: bad archive file name\n"), arch.file_name);
20248 ret = FALSE;
20249 break;
20250 }
20251 namelen = strlen (name);
20252
20253 qualified_name = make_qualified_name (&arch, &nested_arch, name);
20254 if (qualified_name == NULL)
20255 {
20256 error (_("%s: bad archive file name\n"), arch.file_name);
20257 ret = FALSE;
20258 break;
20259 }
20260
20261 if (is_thin_archive && arch.nested_member_origin == 0)
20262 {
20263 /* This is a proxy for an external member of a thin archive. */
20264 Filedata * member_filedata;
20265 char * member_file_name = adjust_relative_path
20266 (filedata->file_name, name, namelen);
20267
20268 if (member_file_name == NULL)
20269 {
20270 ret = FALSE;
20271 break;
20272 }
20273
20274 member_filedata = open_file (member_file_name);
20275 if (member_filedata == NULL)
20276 {
20277 error (_("Input file '%s' is not readable.\n"), member_file_name);
20278 free (member_file_name);
20279 ret = FALSE;
20280 break;
20281 }
20282
20283 archive_file_offset = arch.nested_member_origin;
20284 member_filedata->file_name = qualified_name;
20285
20286 if (! process_object (member_filedata))
20287 ret = FALSE;
20288
20289 close_file (member_filedata);
20290 free (member_file_name);
20291 }
20292 else if (is_thin_archive)
20293 {
20294 Filedata thin_filedata;
20295
20296 memset (&thin_filedata, 0, sizeof (thin_filedata));
20297
20298 /* PR 15140: Allow for corrupt thin archives. */
20299 if (nested_arch.file == NULL)
20300 {
20301 error (_("%s: contains corrupt thin archive: %s\n"),
20302 qualified_name, name);
20303 ret = FALSE;
20304 break;
20305 }
20306
20307 /* This is a proxy for a member of a nested archive. */
20308 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
20309
20310 /* The nested archive file will have been opened and setup by
20311 get_archive_member_name. */
20312 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
20313 {
20314 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
20315 ret = FALSE;
20316 break;
20317 }
20318
20319 thin_filedata.handle = nested_arch.file;
20320 thin_filedata.file_name = qualified_name;
20321
20322 if (! process_object (& thin_filedata))
20323 ret = FALSE;
20324 }
20325 else
20326 {
20327 archive_file_offset = arch.next_arhdr_offset;
20328 arch.next_arhdr_offset += archive_file_size;
20329
20330 filedata->file_name = qualified_name;
20331 if (! process_object (filedata))
20332 ret = FALSE;
20333 }
20334
20335 free (qualified_name);
20336 }
20337
20338 out:
20339 if (nested_arch.file != NULL)
20340 fclose (nested_arch.file);
20341 release_archive (&nested_arch);
20342 release_archive (&arch);
20343
20344 return ret;
20345 }
20346
20347 static bfd_boolean
process_file(char * file_name)20348 process_file (char * file_name)
20349 {
20350 Filedata * filedata = NULL;
20351 struct stat statbuf;
20352 char armag[SARMAG];
20353 bfd_boolean ret = TRUE;
20354
20355 if (stat (file_name, &statbuf) < 0)
20356 {
20357 if (errno == ENOENT)
20358 error (_("'%s': No such file\n"), file_name);
20359 else
20360 error (_("Could not locate '%s'. System error message: %s\n"),
20361 file_name, strerror (errno));
20362 return FALSE;
20363 }
20364
20365 if (! S_ISREG (statbuf.st_mode))
20366 {
20367 error (_("'%s' is not an ordinary file\n"), file_name);
20368 return FALSE;
20369 }
20370
20371 filedata = calloc (1, sizeof * filedata);
20372 if (filedata == NULL)
20373 {
20374 error (_("Out of memory allocating file data structure\n"));
20375 return FALSE;
20376 }
20377
20378 filedata->file_name = file_name;
20379 filedata->handle = fopen (file_name, "rb");
20380 if (filedata->handle == NULL)
20381 {
20382 error (_("Input file '%s' is not readable.\n"), file_name);
20383 free (filedata);
20384 return FALSE;
20385 }
20386
20387 if (fread (armag, SARMAG, 1, filedata->handle) != 1)
20388 {
20389 error (_("%s: Failed to read file's magic number\n"), file_name);
20390 fclose (filedata->handle);
20391 free (filedata);
20392 return FALSE;
20393 }
20394
20395 filedata->file_size = (bfd_size_type) statbuf.st_size;
20396
20397 if (memcmp (armag, ARMAG, SARMAG) == 0)
20398 {
20399 if (! process_archive (filedata, FALSE))
20400 ret = FALSE;
20401 }
20402 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
20403 {
20404 if ( ! process_archive (filedata, TRUE))
20405 ret = FALSE;
20406 }
20407 else
20408 {
20409 if (do_archive_index)
20410 error (_("File %s is not an archive so its index cannot be displayed.\n"),
20411 file_name);
20412
20413 rewind (filedata->handle);
20414 archive_file_size = archive_file_offset = 0;
20415
20416 if (! process_object (filedata))
20417 ret = FALSE;
20418 }
20419
20420 fclose (filedata->handle);
20421 free (filedata);
20422
20423 return ret;
20424 }
20425
20426 #ifdef SUPPORT_DISASSEMBLY
20427 /* Needed by the i386 disassembler. For extra credit, someone could
20428 fix this so that we insert symbolic addresses here, esp for GOT/PLT
20429 symbols. */
20430
20431 void
print_address(unsigned int addr,FILE * outfile)20432 print_address (unsigned int addr, FILE * outfile)
20433 {
20434 fprintf (outfile,"0x%8.8x", addr);
20435 }
20436
20437 /* Needed by the i386 disassembler. */
20438
20439 void
db_task_printsym(unsigned int addr)20440 db_task_printsym (unsigned int addr)
20441 {
20442 print_address (addr, stderr);
20443 }
20444 #endif
20445
20446 int
main(int argc,char ** argv)20447 main (int argc, char ** argv)
20448 {
20449 int err;
20450
20451 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
20452 setlocale (LC_MESSAGES, "");
20453 #endif
20454 #if defined (HAVE_SETLOCALE)
20455 setlocale (LC_CTYPE, "");
20456 #endif
20457 bindtextdomain (PACKAGE, LOCALEDIR);
20458 textdomain (PACKAGE);
20459
20460 expandargv (&argc, &argv);
20461
20462 cmdline.file_name = "<cmdline>";
20463 parse_args (& cmdline, argc, argv);
20464
20465 if (optind < (argc - 1))
20466 show_name = TRUE;
20467 else if (optind >= argc)
20468 {
20469 warn (_("Nothing to do.\n"));
20470 usage (stderr);
20471 }
20472
20473 err = FALSE;
20474 while (optind < argc)
20475 if (! process_file (argv[optind++]))
20476 err = TRUE;
20477
20478 if (cmdline.dump_sects != NULL)
20479 free (cmdline.dump_sects);
20480
20481 free (dump_ctf_symtab_name);
20482 free (dump_ctf_strtab_name);
20483 free (dump_ctf_parent_name);
20484
20485 return err ? EXIT_FAILURE : EXIT_SUCCESS;
20486 }
20487