]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - binutils/readelf.c
[MIPS/GAS] Add Loongson EXT2 Instructions support.
[thirdparty/binutils-gdb.git] / binutils / readelf.c
1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2018 Free Software Foundation, Inc.
3
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
6
7 This file is part of GNU Binutils.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
22 02110-1301, USA. */
23 \f
24 /* The difference between readelf and objdump:
25
26 Both programs are capable of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
28
29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
35
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
38
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
42 \f
43 #include "sysdep.h"
44 #include <assert.h>
45 #include <time.h>
46 #include <zlib.h>
47 #ifdef HAVE_WCHAR_H
48 #include <wchar.h>
49 #endif
50
51 #if __GNUC__ >= 2
52 /* Define BFD64 here, even if our default architecture is 32 bit ELF
53 as this will allow us to read in and parse 64bit and 32bit ELF files.
54 Only do this if we believe that the compiler can support a 64 bit
55 data type. For now we only rely on GCC being able to do this. */
56 #define BFD64
57 #endif
58
59 #include "bfd.h"
60 #include "bucomm.h"
61 #include "elfcomm.h"
62 #include "dwarf.h"
63
64 #include "elf/common.h"
65 #include "elf/external.h"
66 #include "elf/internal.h"
67
68
69 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
70 we can obtain the H8 reloc numbers. We need these for the
71 get_reloc_size() function. We include h8.h again after defining
72 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
73
74 #include "elf/h8.h"
75 #undef _ELF_H8_H
76
77 /* Undo the effects of #including reloc-macros.h. */
78
79 #undef START_RELOC_NUMBERS
80 #undef RELOC_NUMBER
81 #undef FAKE_RELOC
82 #undef EMPTY_RELOC
83 #undef END_RELOC_NUMBERS
84 #undef _RELOC_MACROS_H
85
86 /* The following headers use the elf/reloc-macros.h file to
87 automatically generate relocation recognition functions
88 such as elf_mips_reloc_type() */
89
90 #define RELOC_MACROS_GEN_FUNC
91
92 #include "elf/aarch64.h"
93 #include "elf/alpha.h"
94 #include "elf/arc.h"
95 #include "elf/arm.h"
96 #include "elf/avr.h"
97 #include "elf/bfin.h"
98 #include "elf/cr16.h"
99 #include "elf/cris.h"
100 #include "elf/crx.h"
101 #include "elf/csky.h"
102 #include "elf/d10v.h"
103 #include "elf/d30v.h"
104 #include "elf/dlx.h"
105 #include "elf/epiphany.h"
106 #include "elf/fr30.h"
107 #include "elf/frv.h"
108 #include "elf/ft32.h"
109 #include "elf/h8.h"
110 #include "elf/hppa.h"
111 #include "elf/i386.h"
112 #include "elf/i370.h"
113 #include "elf/i860.h"
114 #include "elf/i960.h"
115 #include "elf/ia64.h"
116 #include "elf/ip2k.h"
117 #include "elf/lm32.h"
118 #include "elf/iq2000.h"
119 #include "elf/m32c.h"
120 #include "elf/m32r.h"
121 #include "elf/m68k.h"
122 #include "elf/m68hc11.h"
123 #include "elf/s12z.h"
124 #include "elf/mcore.h"
125 #include "elf/mep.h"
126 #include "elf/metag.h"
127 #include "elf/microblaze.h"
128 #include "elf/mips.h"
129 #include "elf/mmix.h"
130 #include "elf/mn10200.h"
131 #include "elf/mn10300.h"
132 #include "elf/moxie.h"
133 #include "elf/mt.h"
134 #include "elf/msp430.h"
135 #include "elf/nds32.h"
136 #include "elf/nfp.h"
137 #include "elf/nios2.h"
138 #include "elf/or1k.h"
139 #include "elf/pj.h"
140 #include "elf/ppc.h"
141 #include "elf/ppc64.h"
142 #include "elf/pru.h"
143 #include "elf/riscv.h"
144 #include "elf/rl78.h"
145 #include "elf/rx.h"
146 #include "elf/s390.h"
147 #include "elf/score.h"
148 #include "elf/sh.h"
149 #include "elf/sparc.h"
150 #include "elf/spu.h"
151 #include "elf/tic6x.h"
152 #include "elf/tilegx.h"
153 #include "elf/tilepro.h"
154 #include "elf/v850.h"
155 #include "elf/vax.h"
156 #include "elf/visium.h"
157 #include "elf/wasm32.h"
158 #include "elf/x86-64.h"
159 #include "elf/xc16x.h"
160 #include "elf/xgate.h"
161 #include "elf/xstormy16.h"
162 #include "elf/xtensa.h"
163
164 #include "getopt.h"
165 #include "libiberty.h"
166 #include "safe-ctype.h"
167 #include "filenames.h"
168
169 #ifndef offsetof
170 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
171 #endif
172
173 typedef struct elf_section_list
174 {
175 Elf_Internal_Shdr * hdr;
176 struct elf_section_list * next;
177 } elf_section_list;
178
179 /* Flag bits indicating particular types of dump. */
180 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
181 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
182 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
183 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
184 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
185
186 typedef unsigned char dump_type;
187
188 /* A linked list of the section names for which dumps were requested. */
189 struct dump_list_entry
190 {
191 char * name;
192 dump_type type;
193 struct dump_list_entry * next;
194 };
195
196 typedef struct filedata
197 {
198 const char * file_name;
199 FILE * handle;
200 bfd_size_type file_size;
201 Elf_Internal_Ehdr file_header;
202 Elf_Internal_Shdr * section_headers;
203 Elf_Internal_Phdr * program_headers;
204 char * string_table;
205 unsigned long string_table_length;
206 /* A dynamic array of flags indicating for which sections a dump of
207 some kind has been requested. It is reset on a per-object file
208 basis and then initialised from the cmdline_dump_sects array,
209 the results of interpreting the -w switch, and the
210 dump_sects_byname list. */
211 dump_type * dump_sects;
212 unsigned int num_dump_sects;
213 } Filedata;
214
215 char * program_name = "readelf";
216
217 static unsigned long archive_file_offset;
218 static unsigned long archive_file_size;
219 static unsigned long dynamic_addr;
220 static bfd_size_type dynamic_size;
221 static size_t dynamic_nent;
222 static char * dynamic_strings;
223 static unsigned long dynamic_strings_length;
224 static unsigned long num_dynamic_syms;
225 static Elf_Internal_Sym * dynamic_symbols;
226 static Elf_Internal_Syminfo * dynamic_syminfo;
227 static unsigned long dynamic_syminfo_offset;
228 static unsigned int dynamic_syminfo_nent;
229 static char program_interpreter[PATH_MAX];
230 static bfd_vma dynamic_info[DT_ENCODING];
231 static bfd_vma dynamic_info_DT_GNU_HASH;
232 static bfd_vma version_info[16];
233 static Elf_Internal_Dyn * dynamic_section;
234 static elf_section_list * symtab_shndx_list;
235 static bfd_boolean show_name = FALSE;
236 static bfd_boolean do_dynamic = FALSE;
237 static bfd_boolean do_syms = FALSE;
238 static bfd_boolean do_dyn_syms = FALSE;
239 static bfd_boolean do_reloc = FALSE;
240 static bfd_boolean do_sections = FALSE;
241 static bfd_boolean do_section_groups = FALSE;
242 static bfd_boolean do_section_details = FALSE;
243 static bfd_boolean do_segments = FALSE;
244 static bfd_boolean do_unwind = FALSE;
245 static bfd_boolean do_using_dynamic = FALSE;
246 static bfd_boolean do_header = FALSE;
247 static bfd_boolean do_dump = FALSE;
248 static bfd_boolean do_version = FALSE;
249 static bfd_boolean do_histogram = FALSE;
250 static bfd_boolean do_debugging = FALSE;
251 static bfd_boolean do_arch = FALSE;
252 static bfd_boolean do_notes = FALSE;
253 static bfd_boolean do_archive_index = FALSE;
254 static bfd_boolean is_32bit_elf = FALSE;
255 static bfd_boolean decompress_dumps = FALSE;
256
257 struct group_list
258 {
259 struct group_list * next;
260 unsigned int section_index;
261 };
262
263 struct group
264 {
265 struct group_list * root;
266 unsigned int group_index;
267 };
268
269 static size_t group_count;
270 static struct group * section_groups;
271 static struct group ** section_headers_groups;
272
273 /* A dynamic array of flags indicating for which sections a dump
274 has been requested via command line switches. */
275 static Filedata cmdline;
276
277 static struct dump_list_entry * dump_sects_byname;
278
279 /* How to print a vma value. */
280 typedef enum print_mode
281 {
282 HEX,
283 DEC,
284 DEC_5,
285 UNSIGNED,
286 PREFIX_HEX,
287 FULL_HEX,
288 LONG_HEX
289 }
290 print_mode;
291
292 /* Versioned symbol info. */
293 enum versioned_symbol_info
294 {
295 symbol_undefined,
296 symbol_hidden,
297 symbol_public
298 };
299
300 static const char * get_symbol_version_string
301 (Filedata *, bfd_boolean, const char *, unsigned long, unsigned,
302 Elf_Internal_Sym *, enum versioned_symbol_info *, unsigned short *);
303
304 #define UNKNOWN -1
305
306 #define SECTION_NAME(X) \
307 ((X) == NULL ? _("<none>") \
308 : filedata->string_table == NULL ? _("<no-strings>") \
309 : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>") \
310 : filedata->string_table + (X)->sh_name))
311
312 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
313
314 #define GET_ELF_SYMBOLS(file, section, sym_count) \
315 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
316 : get_64bit_elf_symbols (file, section, sym_count))
317
318 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
319 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
320 already been called and verified that the string exists. */
321 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
322
323 #define REMOVE_ARCH_BITS(ADDR) \
324 do \
325 { \
326 if (filedata->file_header.e_machine == EM_ARM) \
327 (ADDR) &= ~1; \
328 } \
329 while (0)
330 \f
331 /* Print a BFD_VMA to an internal buffer, for use in error messages.
332 BFD_FMA_FMT can't be used in translated strings. */
333
334 static const char *
335 bfd_vmatoa (char *fmtch, bfd_vma value)
336 {
337 /* bfd_vmatoa is used more then once in a printf call for output.
338 Cycle through an array of buffers. */
339 static int buf_pos = 0;
340 static struct bfd_vmatoa_buf
341 {
342 char place[64];
343 } buf[4];
344 char *ret;
345 char fmt[32];
346
347 ret = buf[buf_pos++].place;
348 buf_pos %= ARRAY_SIZE (buf);
349
350 sprintf (fmt, "%%%s%s", BFD_VMA_FMT, fmtch);
351 snprintf (ret, sizeof (buf[0].place), fmt, value);
352 return ret;
353 }
354
355 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
356 OFFSET + the offset of the current archive member, if we are examining an
357 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
358 allocate a buffer using malloc and fill that. In either case return the
359 pointer to the start of the retrieved data or NULL if something went wrong.
360 If something does go wrong and REASON is not NULL then emit an error
361 message using REASON as part of the context. */
362
363 static void *
364 get_data (void * var,
365 Filedata * filedata,
366 unsigned long offset,
367 bfd_size_type size,
368 bfd_size_type nmemb,
369 const char * reason)
370 {
371 void * mvar;
372 bfd_size_type amt = size * nmemb;
373
374 if (size == 0 || nmemb == 0)
375 return NULL;
376
377 /* If the size_t type is smaller than the bfd_size_type, eg because
378 you are building a 32-bit tool on a 64-bit host, then make sure
379 that when the sizes are cast to (size_t) no information is lost. */
380 if (sizeof (size_t) < sizeof (bfd_size_type)
381 && ( (bfd_size_type) ((size_t) size) != size
382 || (bfd_size_type) ((size_t) nmemb) != nmemb))
383 {
384 if (reason)
385 error (_("Size truncation prevents reading %s"
386 " elements of size %s for %s\n"),
387 bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
388 return NULL;
389 }
390
391 /* Check for size overflow. */
392 if (amt < nmemb)
393 {
394 if (reason)
395 error (_("Size overflow prevents reading %s"
396 " elements of size %s for %s\n"),
397 bfd_vmatoa ("u", nmemb), bfd_vmatoa ("u", size), reason);
398 return NULL;
399 }
400
401 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
402 attempting to allocate memory when the read is bound to fail. */
403 if (amt > filedata->file_size
404 || offset + archive_file_offset + amt > filedata->file_size)
405 {
406 if (reason)
407 error (_("Reading %s bytes extends past end of file for %s\n"),
408 bfd_vmatoa ("u", amt), reason);
409 return NULL;
410 }
411
412 if (fseek (filedata->handle, archive_file_offset + offset, SEEK_SET))
413 {
414 if (reason)
415 error (_("Unable to seek to 0x%lx for %s\n"),
416 archive_file_offset + offset, reason);
417 return NULL;
418 }
419
420 mvar = var;
421 if (mvar == NULL)
422 {
423 /* Check for overflow. */
424 if (nmemb < (~(bfd_size_type) 0 - 1) / size)
425 /* + 1 so that we can '\0' terminate invalid string table sections. */
426 mvar = malloc ((size_t) amt + 1);
427
428 if (mvar == NULL)
429 {
430 if (reason)
431 error (_("Out of memory allocating %s bytes for %s\n"),
432 bfd_vmatoa ("u", amt), reason);
433 return NULL;
434 }
435
436 ((char *) mvar)[amt] = '\0';
437 }
438
439 if (fread (mvar, (size_t) size, (size_t) nmemb, filedata->handle) != nmemb)
440 {
441 if (reason)
442 error (_("Unable to read in %s bytes of %s\n"),
443 bfd_vmatoa ("u", amt), reason);
444 if (mvar != var)
445 free (mvar);
446 return NULL;
447 }
448
449 return mvar;
450 }
451
452 /* Print a VMA value in the MODE specified.
453 Returns the number of characters displayed. */
454
455 static unsigned int
456 print_vma (bfd_vma vma, print_mode mode)
457 {
458 unsigned int nc = 0;
459
460 switch (mode)
461 {
462 case FULL_HEX:
463 nc = printf ("0x");
464 /* Fall through. */
465 case LONG_HEX:
466 #ifdef BFD64
467 if (is_32bit_elf)
468 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
469 #endif
470 printf_vma (vma);
471 return nc + 16;
472
473 case DEC_5:
474 if (vma <= 99999)
475 return printf ("%5" BFD_VMA_FMT "d", vma);
476 /* Fall through. */
477 case PREFIX_HEX:
478 nc = printf ("0x");
479 /* Fall through. */
480 case HEX:
481 return nc + printf ("%" BFD_VMA_FMT "x", vma);
482
483 case DEC:
484 return printf ("%" BFD_VMA_FMT "d", vma);
485
486 case UNSIGNED:
487 return printf ("%" BFD_VMA_FMT "u", vma);
488
489 default:
490 /* FIXME: Report unrecognised mode ? */
491 return 0;
492 }
493 }
494
495 /* Display a symbol on stdout. Handles the display of control characters and
496 multibye characters (assuming the host environment supports them).
497
498 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
499
500 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
501 padding as necessary.
502
503 Returns the number of emitted characters. */
504
505 static unsigned int
506 print_symbol (signed int width, const char *symbol)
507 {
508 bfd_boolean extra_padding = FALSE;
509 signed int num_printed = 0;
510 #ifdef HAVE_MBSTATE_T
511 mbstate_t state;
512 #endif
513 unsigned int width_remaining;
514
515 if (width < 0)
516 {
517 /* Keep the width positive. This helps the code below. */
518 width = - width;
519 extra_padding = TRUE;
520 }
521 else if (width == 0)
522 return 0;
523
524 if (do_wide)
525 /* Set the remaining width to a very large value.
526 This simplifies the code below. */
527 width_remaining = INT_MAX;
528 else
529 width_remaining = width;
530
531 #ifdef HAVE_MBSTATE_T
532 /* Initialise the multibyte conversion state. */
533 memset (& state, 0, sizeof (state));
534 #endif
535
536 while (width_remaining)
537 {
538 size_t n;
539 const char c = *symbol++;
540
541 if (c == 0)
542 break;
543
544 /* Do not print control characters directly as they can affect terminal
545 settings. Such characters usually appear in the names generated
546 by the assembler for local labels. */
547 if (ISCNTRL (c))
548 {
549 if (width_remaining < 2)
550 break;
551
552 printf ("^%c", c + 0x40);
553 width_remaining -= 2;
554 num_printed += 2;
555 }
556 else if (ISPRINT (c))
557 {
558 putchar (c);
559 width_remaining --;
560 num_printed ++;
561 }
562 else
563 {
564 #ifdef HAVE_MBSTATE_T
565 wchar_t w;
566 #endif
567 /* Let printf do the hard work of displaying multibyte characters. */
568 printf ("%.1s", symbol - 1);
569 width_remaining --;
570 num_printed ++;
571
572 #ifdef HAVE_MBSTATE_T
573 /* Try to find out how many bytes made up the character that was
574 just printed. Advance the symbol pointer past the bytes that
575 were displayed. */
576 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
577 #else
578 n = 1;
579 #endif
580 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
581 symbol += (n - 1);
582 }
583 }
584
585 if (extra_padding && num_printed < width)
586 {
587 /* Fill in the remaining spaces. */
588 printf ("%-*s", width - num_printed, " ");
589 num_printed = width;
590 }
591
592 return num_printed;
593 }
594
595 /* Returns a pointer to a static buffer containing a printable version of
596 the given section's name. Like print_symbol, except that it does not try
597 to print multibyte characters, it just interprets them as hex values. */
598
599 static const char *
600 printable_section_name (Filedata * filedata, const Elf_Internal_Shdr * sec)
601 {
602 #define MAX_PRINT_SEC_NAME_LEN 128
603 static char sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
604 const char * name = SECTION_NAME (sec);
605 char * buf = sec_name_buf;
606 char c;
607 unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
608
609 while ((c = * name ++) != 0)
610 {
611 if (ISCNTRL (c))
612 {
613 if (remaining < 2)
614 break;
615
616 * buf ++ = '^';
617 * buf ++ = c + 0x40;
618 remaining -= 2;
619 }
620 else if (ISPRINT (c))
621 {
622 * buf ++ = c;
623 remaining -= 1;
624 }
625 else
626 {
627 static char hex[17] = "0123456789ABCDEF";
628
629 if (remaining < 4)
630 break;
631 * buf ++ = '<';
632 * buf ++ = hex[(c & 0xf0) >> 4];
633 * buf ++ = hex[c & 0x0f];
634 * buf ++ = '>';
635 remaining -= 4;
636 }
637
638 if (remaining == 0)
639 break;
640 }
641
642 * buf = 0;
643 return sec_name_buf;
644 }
645
646 static const char *
647 printable_section_name_from_index (Filedata * filedata, unsigned long ndx)
648 {
649 if (ndx >= filedata->file_header.e_shnum)
650 return _("<corrupt>");
651
652 return printable_section_name (filedata, filedata->section_headers + ndx);
653 }
654
655 /* Return a pointer to section NAME, or NULL if no such section exists. */
656
657 static Elf_Internal_Shdr *
658 find_section (Filedata * filedata, const char * name)
659 {
660 unsigned int i;
661
662 if (filedata->section_headers == NULL)
663 return NULL;
664
665 for (i = 0; i < filedata->file_header.e_shnum; i++)
666 if (streq (SECTION_NAME (filedata->section_headers + i), name))
667 return filedata->section_headers + i;
668
669 return NULL;
670 }
671
672 /* Return a pointer to a section containing ADDR, or NULL if no such
673 section exists. */
674
675 static Elf_Internal_Shdr *
676 find_section_by_address (Filedata * filedata, bfd_vma addr)
677 {
678 unsigned int i;
679
680 if (filedata->section_headers == NULL)
681 return NULL;
682
683 for (i = 0; i < filedata->file_header.e_shnum; i++)
684 {
685 Elf_Internal_Shdr *sec = filedata->section_headers + i;
686
687 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
688 return sec;
689 }
690
691 return NULL;
692 }
693
694 static Elf_Internal_Shdr *
695 find_section_by_type (Filedata * filedata, unsigned int type)
696 {
697 unsigned int i;
698
699 if (filedata->section_headers == NULL)
700 return NULL;
701
702 for (i = 0; i < filedata->file_header.e_shnum; i++)
703 {
704 Elf_Internal_Shdr *sec = filedata->section_headers + i;
705
706 if (sec->sh_type == type)
707 return sec;
708 }
709
710 return NULL;
711 }
712
713 /* Return a pointer to section NAME, or NULL if no such section exists,
714 restricted to the list of sections given in SET. */
715
716 static Elf_Internal_Shdr *
717 find_section_in_set (Filedata * filedata, const char * name, unsigned int * set)
718 {
719 unsigned int i;
720
721 if (filedata->section_headers == NULL)
722 return NULL;
723
724 if (set != NULL)
725 {
726 while ((i = *set++) > 0)
727 {
728 /* See PR 21156 for a reproducer. */
729 if (i >= filedata->file_header.e_shnum)
730 continue; /* FIXME: Should we issue an error message ? */
731
732 if (streq (SECTION_NAME (filedata->section_headers + i), name))
733 return filedata->section_headers + i;
734 }
735 }
736
737 return find_section (filedata, name);
738 }
739
740 /* Read an unsigned LEB128 encoded value from DATA.
741 Set *LENGTH_RETURN to the number of bytes read. */
742
743 static inline unsigned long
744 read_uleb128 (unsigned char * data,
745 unsigned int * length_return,
746 const unsigned char * const end)
747 {
748 return read_leb128 (data, length_return, FALSE, end);
749 }
750
751 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
752 This OS has so many departures from the ELF standard that we test it at
753 many places. */
754
755 static inline bfd_boolean
756 is_ia64_vms (Filedata * filedata)
757 {
758 return filedata->file_header.e_machine == EM_IA_64
759 && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
760 }
761
762 /* Guess the relocation size commonly used by the specific machines. */
763
764 static bfd_boolean
765 guess_is_rela (unsigned int e_machine)
766 {
767 switch (e_machine)
768 {
769 /* Targets that use REL relocations. */
770 case EM_386:
771 case EM_IAMCU:
772 case EM_960:
773 case EM_ARM:
774 case EM_D10V:
775 case EM_CYGNUS_D10V:
776 case EM_DLX:
777 case EM_MIPS:
778 case EM_MIPS_RS3_LE:
779 case EM_CYGNUS_M32R:
780 case EM_SCORE:
781 case EM_XGATE:
782 case EM_NFP:
783 return FALSE;
784
785 /* Targets that use RELA relocations. */
786 case EM_68K:
787 case EM_860:
788 case EM_AARCH64:
789 case EM_ADAPTEVA_EPIPHANY:
790 case EM_ALPHA:
791 case EM_ALTERA_NIOS2:
792 case EM_ARC:
793 case EM_ARC_COMPACT:
794 case EM_ARC_COMPACT2:
795 case EM_AVR:
796 case EM_AVR_OLD:
797 case EM_BLACKFIN:
798 case EM_CR16:
799 case EM_CRIS:
800 case EM_CRX:
801 case EM_CSKY:
802 case EM_D30V:
803 case EM_CYGNUS_D30V:
804 case EM_FR30:
805 case EM_FT32:
806 case EM_CYGNUS_FR30:
807 case EM_CYGNUS_FRV:
808 case EM_H8S:
809 case EM_H8_300:
810 case EM_H8_300H:
811 case EM_IA_64:
812 case EM_IP2K:
813 case EM_IP2K_OLD:
814 case EM_IQ2000:
815 case EM_LATTICEMICO32:
816 case EM_M32C_OLD:
817 case EM_M32C:
818 case EM_M32R:
819 case EM_MCORE:
820 case EM_CYGNUS_MEP:
821 case EM_METAG:
822 case EM_MMIX:
823 case EM_MN10200:
824 case EM_CYGNUS_MN10200:
825 case EM_MN10300:
826 case EM_CYGNUS_MN10300:
827 case EM_MOXIE:
828 case EM_MSP430:
829 case EM_MSP430_OLD:
830 case EM_MT:
831 case EM_NDS32:
832 case EM_NIOS32:
833 case EM_OR1K:
834 case EM_PPC64:
835 case EM_PPC:
836 case EM_TI_PRU:
837 case EM_RISCV:
838 case EM_RL78:
839 case EM_RX:
840 case EM_S390:
841 case EM_S390_OLD:
842 case EM_SH:
843 case EM_SPARC:
844 case EM_SPARC32PLUS:
845 case EM_SPARCV9:
846 case EM_SPU:
847 case EM_TI_C6000:
848 case EM_TILEGX:
849 case EM_TILEPRO:
850 case EM_V800:
851 case EM_V850:
852 case EM_CYGNUS_V850:
853 case EM_VAX:
854 case EM_VISIUM:
855 case EM_X86_64:
856 case EM_L1OM:
857 case EM_K1OM:
858 case EM_XSTORMY16:
859 case EM_XTENSA:
860 case EM_XTENSA_OLD:
861 case EM_MICROBLAZE:
862 case EM_MICROBLAZE_OLD:
863 case EM_WEBASSEMBLY:
864 return TRUE;
865
866 case EM_68HC05:
867 case EM_68HC08:
868 case EM_68HC11:
869 case EM_68HC16:
870 case EM_FX66:
871 case EM_ME16:
872 case EM_MMA:
873 case EM_NCPU:
874 case EM_NDR1:
875 case EM_PCP:
876 case EM_ST100:
877 case EM_ST19:
878 case EM_ST7:
879 case EM_ST9PLUS:
880 case EM_STARCORE:
881 case EM_SVX:
882 case EM_TINYJ:
883 default:
884 warn (_("Don't know about relocations on this machine architecture\n"));
885 return FALSE;
886 }
887 }
888
889 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
890 Returns TRUE upon success, FALSE otherwise. If successful then a
891 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
892 and the number of relocs loaded is placed in *NRELASP. It is the caller's
893 responsibility to free the allocated buffer. */
894
895 static bfd_boolean
896 slurp_rela_relocs (Filedata * filedata,
897 unsigned long rel_offset,
898 unsigned long rel_size,
899 Elf_Internal_Rela ** relasp,
900 unsigned long * nrelasp)
901 {
902 Elf_Internal_Rela * relas;
903 size_t nrelas;
904 unsigned int i;
905
906 if (is_32bit_elf)
907 {
908 Elf32_External_Rela * erelas;
909
910 erelas = (Elf32_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
911 rel_size, _("32-bit relocation data"));
912 if (!erelas)
913 return FALSE;
914
915 nrelas = rel_size / sizeof (Elf32_External_Rela);
916
917 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
918 sizeof (Elf_Internal_Rela));
919
920 if (relas == NULL)
921 {
922 free (erelas);
923 error (_("out of memory parsing relocs\n"));
924 return FALSE;
925 }
926
927 for (i = 0; i < nrelas; i++)
928 {
929 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
930 relas[i].r_info = BYTE_GET (erelas[i].r_info);
931 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
932 }
933
934 free (erelas);
935 }
936 else
937 {
938 Elf64_External_Rela * erelas;
939
940 erelas = (Elf64_External_Rela *) get_data (NULL, filedata, rel_offset, 1,
941 rel_size, _("64-bit relocation data"));
942 if (!erelas)
943 return FALSE;
944
945 nrelas = rel_size / sizeof (Elf64_External_Rela);
946
947 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
948 sizeof (Elf_Internal_Rela));
949
950 if (relas == NULL)
951 {
952 free (erelas);
953 error (_("out of memory parsing relocs\n"));
954 return FALSE;
955 }
956
957 for (i = 0; i < nrelas; i++)
958 {
959 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
960 relas[i].r_info = BYTE_GET (erelas[i].r_info);
961 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
962
963 /* The #ifdef BFD64 below is to prevent a compile time
964 warning. We know that if we do not have a 64 bit data
965 type that we will never execute this code anyway. */
966 #ifdef BFD64
967 if (filedata->file_header.e_machine == EM_MIPS
968 && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
969 {
970 /* In little-endian objects, r_info isn't really a
971 64-bit little-endian value: it has a 32-bit
972 little-endian symbol index followed by four
973 individual byte fields. Reorder INFO
974 accordingly. */
975 bfd_vma inf = relas[i].r_info;
976 inf = (((inf & 0xffffffff) << 32)
977 | ((inf >> 56) & 0xff)
978 | ((inf >> 40) & 0xff00)
979 | ((inf >> 24) & 0xff0000)
980 | ((inf >> 8) & 0xff000000));
981 relas[i].r_info = inf;
982 }
983 #endif /* BFD64 */
984 }
985
986 free (erelas);
987 }
988
989 *relasp = relas;
990 *nrelasp = nrelas;
991 return TRUE;
992 }
993
994 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
995 Returns TRUE upon success, FALSE otherwise. If successful then a
996 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
997 and the number of relocs loaded is placed in *NRELSP. It is the caller's
998 responsibility to free the allocated buffer. */
999
1000 static bfd_boolean
1001 slurp_rel_relocs (Filedata * filedata,
1002 unsigned long rel_offset,
1003 unsigned long rel_size,
1004 Elf_Internal_Rela ** relsp,
1005 unsigned long * nrelsp)
1006 {
1007 Elf_Internal_Rela * rels;
1008 size_t nrels;
1009 unsigned int i;
1010
1011 if (is_32bit_elf)
1012 {
1013 Elf32_External_Rel * erels;
1014
1015 erels = (Elf32_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1016 rel_size, _("32-bit relocation data"));
1017 if (!erels)
1018 return FALSE;
1019
1020 nrels = rel_size / sizeof (Elf32_External_Rel);
1021
1022 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1023
1024 if (rels == NULL)
1025 {
1026 free (erels);
1027 error (_("out of memory parsing relocs\n"));
1028 return FALSE;
1029 }
1030
1031 for (i = 0; i < nrels; i++)
1032 {
1033 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1034 rels[i].r_info = BYTE_GET (erels[i].r_info);
1035 rels[i].r_addend = 0;
1036 }
1037
1038 free (erels);
1039 }
1040 else
1041 {
1042 Elf64_External_Rel * erels;
1043
1044 erels = (Elf64_External_Rel *) get_data (NULL, filedata, rel_offset, 1,
1045 rel_size, _("64-bit relocation data"));
1046 if (!erels)
1047 return FALSE;
1048
1049 nrels = rel_size / sizeof (Elf64_External_Rel);
1050
1051 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1052
1053 if (rels == NULL)
1054 {
1055 free (erels);
1056 error (_("out of memory parsing relocs\n"));
1057 return FALSE;
1058 }
1059
1060 for (i = 0; i < nrels; i++)
1061 {
1062 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1063 rels[i].r_info = BYTE_GET (erels[i].r_info);
1064 rels[i].r_addend = 0;
1065
1066 /* The #ifdef BFD64 below is to prevent a compile time
1067 warning. We know that if we do not have a 64 bit data
1068 type that we will never execute this code anyway. */
1069 #ifdef BFD64
1070 if (filedata->file_header.e_machine == EM_MIPS
1071 && filedata->file_header.e_ident[EI_DATA] != ELFDATA2MSB)
1072 {
1073 /* In little-endian objects, r_info isn't really a
1074 64-bit little-endian value: it has a 32-bit
1075 little-endian symbol index followed by four
1076 individual byte fields. Reorder INFO
1077 accordingly. */
1078 bfd_vma inf = rels[i].r_info;
1079 inf = (((inf & 0xffffffff) << 32)
1080 | ((inf >> 56) & 0xff)
1081 | ((inf >> 40) & 0xff00)
1082 | ((inf >> 24) & 0xff0000)
1083 | ((inf >> 8) & 0xff000000));
1084 rels[i].r_info = inf;
1085 }
1086 #endif /* BFD64 */
1087 }
1088
1089 free (erels);
1090 }
1091
1092 *relsp = rels;
1093 *nrelsp = nrels;
1094 return TRUE;
1095 }
1096
1097 /* Returns the reloc type extracted from the reloc info field. */
1098
1099 static unsigned int
1100 get_reloc_type (Filedata * filedata, bfd_vma reloc_info)
1101 {
1102 if (is_32bit_elf)
1103 return ELF32_R_TYPE (reloc_info);
1104
1105 switch (filedata->file_header.e_machine)
1106 {
1107 case EM_MIPS:
1108 /* Note: We assume that reloc_info has already been adjusted for us. */
1109 return ELF64_MIPS_R_TYPE (reloc_info);
1110
1111 case EM_SPARCV9:
1112 return ELF64_R_TYPE_ID (reloc_info);
1113
1114 default:
1115 return ELF64_R_TYPE (reloc_info);
1116 }
1117 }
1118
1119 /* Return the symbol index extracted from the reloc info field. */
1120
1121 static bfd_vma
1122 get_reloc_symindex (bfd_vma reloc_info)
1123 {
1124 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1125 }
1126
1127 static inline bfd_boolean
1128 uses_msp430x_relocs (Filedata * filedata)
1129 {
1130 return
1131 filedata->file_header.e_machine == EM_MSP430 /* Paranoia. */
1132 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1133 && (((filedata->file_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1134 /* TI compiler uses ELFOSABI_NONE. */
1135 || (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1136 }
1137
1138 /* Display the contents of the relocation data found at the specified
1139 offset. */
1140
1141 static bfd_boolean
1142 dump_relocations (Filedata * filedata,
1143 unsigned long rel_offset,
1144 unsigned long rel_size,
1145 Elf_Internal_Sym * symtab,
1146 unsigned long nsyms,
1147 char * strtab,
1148 unsigned long strtablen,
1149 int is_rela,
1150 bfd_boolean is_dynsym)
1151 {
1152 unsigned long i;
1153 Elf_Internal_Rela * rels;
1154 bfd_boolean res = TRUE;
1155
1156 if (is_rela == UNKNOWN)
1157 is_rela = guess_is_rela (filedata->file_header.e_machine);
1158
1159 if (is_rela)
1160 {
1161 if (!slurp_rela_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1162 return FALSE;
1163 }
1164 else
1165 {
1166 if (!slurp_rel_relocs (filedata, rel_offset, rel_size, &rels, &rel_size))
1167 return FALSE;
1168 }
1169
1170 if (is_32bit_elf)
1171 {
1172 if (is_rela)
1173 {
1174 if (do_wide)
1175 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1176 else
1177 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1178 }
1179 else
1180 {
1181 if (do_wide)
1182 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1183 else
1184 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1185 }
1186 }
1187 else
1188 {
1189 if (is_rela)
1190 {
1191 if (do_wide)
1192 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1193 else
1194 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1195 }
1196 else
1197 {
1198 if (do_wide)
1199 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1200 else
1201 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1202 }
1203 }
1204
1205 for (i = 0; i < rel_size; i++)
1206 {
1207 const char * rtype;
1208 bfd_vma offset;
1209 bfd_vma inf;
1210 bfd_vma symtab_index;
1211 bfd_vma type;
1212
1213 offset = rels[i].r_offset;
1214 inf = rels[i].r_info;
1215
1216 type = get_reloc_type (filedata, inf);
1217 symtab_index = get_reloc_symindex (inf);
1218
1219 if (is_32bit_elf)
1220 {
1221 printf ("%8.8lx %8.8lx ",
1222 (unsigned long) offset & 0xffffffff,
1223 (unsigned long) inf & 0xffffffff);
1224 }
1225 else
1226 {
1227 #if BFD_HOST_64BIT_LONG
1228 printf (do_wide
1229 ? "%16.16lx %16.16lx "
1230 : "%12.12lx %12.12lx ",
1231 offset, inf);
1232 #elif BFD_HOST_64BIT_LONG_LONG
1233 #ifndef __MSVCRT__
1234 printf (do_wide
1235 ? "%16.16llx %16.16llx "
1236 : "%12.12llx %12.12llx ",
1237 offset, inf);
1238 #else
1239 printf (do_wide
1240 ? "%16.16I64x %16.16I64x "
1241 : "%12.12I64x %12.12I64x ",
1242 offset, inf);
1243 #endif
1244 #else
1245 printf (do_wide
1246 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1247 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1248 _bfd_int64_high (offset),
1249 _bfd_int64_low (offset),
1250 _bfd_int64_high (inf),
1251 _bfd_int64_low (inf));
1252 #endif
1253 }
1254
1255 switch (filedata->file_header.e_machine)
1256 {
1257 default:
1258 rtype = NULL;
1259 break;
1260
1261 case EM_AARCH64:
1262 rtype = elf_aarch64_reloc_type (type);
1263 break;
1264
1265 case EM_M32R:
1266 case EM_CYGNUS_M32R:
1267 rtype = elf_m32r_reloc_type (type);
1268 break;
1269
1270 case EM_386:
1271 case EM_IAMCU:
1272 rtype = elf_i386_reloc_type (type);
1273 break;
1274
1275 case EM_68HC11:
1276 case EM_68HC12:
1277 rtype = elf_m68hc11_reloc_type (type);
1278 break;
1279
1280 case EM_S12Z:
1281 rtype = elf_s12z_reloc_type (type);
1282 break;
1283
1284 case EM_68K:
1285 rtype = elf_m68k_reloc_type (type);
1286 break;
1287
1288 case EM_960:
1289 rtype = elf_i960_reloc_type (type);
1290 break;
1291
1292 case EM_AVR:
1293 case EM_AVR_OLD:
1294 rtype = elf_avr_reloc_type (type);
1295 break;
1296
1297 case EM_OLD_SPARCV9:
1298 case EM_SPARC32PLUS:
1299 case EM_SPARCV9:
1300 case EM_SPARC:
1301 rtype = elf_sparc_reloc_type (type);
1302 break;
1303
1304 case EM_SPU:
1305 rtype = elf_spu_reloc_type (type);
1306 break;
1307
1308 case EM_V800:
1309 rtype = v800_reloc_type (type);
1310 break;
1311 case EM_V850:
1312 case EM_CYGNUS_V850:
1313 rtype = v850_reloc_type (type);
1314 break;
1315
1316 case EM_D10V:
1317 case EM_CYGNUS_D10V:
1318 rtype = elf_d10v_reloc_type (type);
1319 break;
1320
1321 case EM_D30V:
1322 case EM_CYGNUS_D30V:
1323 rtype = elf_d30v_reloc_type (type);
1324 break;
1325
1326 case EM_DLX:
1327 rtype = elf_dlx_reloc_type (type);
1328 break;
1329
1330 case EM_SH:
1331 rtype = elf_sh_reloc_type (type);
1332 break;
1333
1334 case EM_MN10300:
1335 case EM_CYGNUS_MN10300:
1336 rtype = elf_mn10300_reloc_type (type);
1337 break;
1338
1339 case EM_MN10200:
1340 case EM_CYGNUS_MN10200:
1341 rtype = elf_mn10200_reloc_type (type);
1342 break;
1343
1344 case EM_FR30:
1345 case EM_CYGNUS_FR30:
1346 rtype = elf_fr30_reloc_type (type);
1347 break;
1348
1349 case EM_CYGNUS_FRV:
1350 rtype = elf_frv_reloc_type (type);
1351 break;
1352
1353 case EM_CSKY:
1354 rtype = elf_csky_reloc_type (type);
1355 break;
1356
1357 case EM_FT32:
1358 rtype = elf_ft32_reloc_type (type);
1359 break;
1360
1361 case EM_MCORE:
1362 rtype = elf_mcore_reloc_type (type);
1363 break;
1364
1365 case EM_MMIX:
1366 rtype = elf_mmix_reloc_type (type);
1367 break;
1368
1369 case EM_MOXIE:
1370 rtype = elf_moxie_reloc_type (type);
1371 break;
1372
1373 case EM_MSP430:
1374 if (uses_msp430x_relocs (filedata))
1375 {
1376 rtype = elf_msp430x_reloc_type (type);
1377 break;
1378 }
1379 /* Fall through. */
1380 case EM_MSP430_OLD:
1381 rtype = elf_msp430_reloc_type (type);
1382 break;
1383
1384 case EM_NDS32:
1385 rtype = elf_nds32_reloc_type (type);
1386 break;
1387
1388 case EM_PPC:
1389 rtype = elf_ppc_reloc_type (type);
1390 break;
1391
1392 case EM_PPC64:
1393 rtype = elf_ppc64_reloc_type (type);
1394 break;
1395
1396 case EM_MIPS:
1397 case EM_MIPS_RS3_LE:
1398 rtype = elf_mips_reloc_type (type);
1399 break;
1400
1401 case EM_RISCV:
1402 rtype = elf_riscv_reloc_type (type);
1403 break;
1404
1405 case EM_ALPHA:
1406 rtype = elf_alpha_reloc_type (type);
1407 break;
1408
1409 case EM_ARM:
1410 rtype = elf_arm_reloc_type (type);
1411 break;
1412
1413 case EM_ARC:
1414 case EM_ARC_COMPACT:
1415 case EM_ARC_COMPACT2:
1416 rtype = elf_arc_reloc_type (type);
1417 break;
1418
1419 case EM_PARISC:
1420 rtype = elf_hppa_reloc_type (type);
1421 break;
1422
1423 case EM_H8_300:
1424 case EM_H8_300H:
1425 case EM_H8S:
1426 rtype = elf_h8_reloc_type (type);
1427 break;
1428
1429 case EM_OR1K:
1430 rtype = elf_or1k_reloc_type (type);
1431 break;
1432
1433 case EM_PJ:
1434 case EM_PJ_OLD:
1435 rtype = elf_pj_reloc_type (type);
1436 break;
1437 case EM_IA_64:
1438 rtype = elf_ia64_reloc_type (type);
1439 break;
1440
1441 case EM_CRIS:
1442 rtype = elf_cris_reloc_type (type);
1443 break;
1444
1445 case EM_860:
1446 rtype = elf_i860_reloc_type (type);
1447 break;
1448
1449 case EM_X86_64:
1450 case EM_L1OM:
1451 case EM_K1OM:
1452 rtype = elf_x86_64_reloc_type (type);
1453 break;
1454
1455 case EM_S370:
1456 rtype = i370_reloc_type (type);
1457 break;
1458
1459 case EM_S390_OLD:
1460 case EM_S390:
1461 rtype = elf_s390_reloc_type (type);
1462 break;
1463
1464 case EM_SCORE:
1465 rtype = elf_score_reloc_type (type);
1466 break;
1467
1468 case EM_XSTORMY16:
1469 rtype = elf_xstormy16_reloc_type (type);
1470 break;
1471
1472 case EM_CRX:
1473 rtype = elf_crx_reloc_type (type);
1474 break;
1475
1476 case EM_VAX:
1477 rtype = elf_vax_reloc_type (type);
1478 break;
1479
1480 case EM_VISIUM:
1481 rtype = elf_visium_reloc_type (type);
1482 break;
1483
1484 case EM_ADAPTEVA_EPIPHANY:
1485 rtype = elf_epiphany_reloc_type (type);
1486 break;
1487
1488 case EM_IP2K:
1489 case EM_IP2K_OLD:
1490 rtype = elf_ip2k_reloc_type (type);
1491 break;
1492
1493 case EM_IQ2000:
1494 rtype = elf_iq2000_reloc_type (type);
1495 break;
1496
1497 case EM_XTENSA_OLD:
1498 case EM_XTENSA:
1499 rtype = elf_xtensa_reloc_type (type);
1500 break;
1501
1502 case EM_LATTICEMICO32:
1503 rtype = elf_lm32_reloc_type (type);
1504 break;
1505
1506 case EM_M32C_OLD:
1507 case EM_M32C:
1508 rtype = elf_m32c_reloc_type (type);
1509 break;
1510
1511 case EM_MT:
1512 rtype = elf_mt_reloc_type (type);
1513 break;
1514
1515 case EM_BLACKFIN:
1516 rtype = elf_bfin_reloc_type (type);
1517 break;
1518
1519 case EM_CYGNUS_MEP:
1520 rtype = elf_mep_reloc_type (type);
1521 break;
1522
1523 case EM_CR16:
1524 rtype = elf_cr16_reloc_type (type);
1525 break;
1526
1527 case EM_MICROBLAZE:
1528 case EM_MICROBLAZE_OLD:
1529 rtype = elf_microblaze_reloc_type (type);
1530 break;
1531
1532 case EM_RL78:
1533 rtype = elf_rl78_reloc_type (type);
1534 break;
1535
1536 case EM_RX:
1537 rtype = elf_rx_reloc_type (type);
1538 break;
1539
1540 case EM_METAG:
1541 rtype = elf_metag_reloc_type (type);
1542 break;
1543
1544 case EM_XC16X:
1545 case EM_C166:
1546 rtype = elf_xc16x_reloc_type (type);
1547 break;
1548
1549 case EM_TI_C6000:
1550 rtype = elf_tic6x_reloc_type (type);
1551 break;
1552
1553 case EM_TILEGX:
1554 rtype = elf_tilegx_reloc_type (type);
1555 break;
1556
1557 case EM_TILEPRO:
1558 rtype = elf_tilepro_reloc_type (type);
1559 break;
1560
1561 case EM_WEBASSEMBLY:
1562 rtype = elf_wasm32_reloc_type (type);
1563 break;
1564
1565 case EM_XGATE:
1566 rtype = elf_xgate_reloc_type (type);
1567 break;
1568
1569 case EM_ALTERA_NIOS2:
1570 rtype = elf_nios2_reloc_type (type);
1571 break;
1572
1573 case EM_TI_PRU:
1574 rtype = elf_pru_reloc_type (type);
1575 break;
1576
1577 case EM_NFP:
1578 if (EF_NFP_MACH (filedata->file_header.e_flags) == E_NFP_MACH_3200)
1579 rtype = elf_nfp3200_reloc_type (type);
1580 else
1581 rtype = elf_nfp_reloc_type (type);
1582 break;
1583 }
1584
1585 if (rtype == NULL)
1586 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1587 else
1588 printf (do_wide ? "%-22s" : "%-17.17s", rtype);
1589
1590 if (filedata->file_header.e_machine == EM_ALPHA
1591 && rtype != NULL
1592 && streq (rtype, "R_ALPHA_LITUSE")
1593 && is_rela)
1594 {
1595 switch (rels[i].r_addend)
1596 {
1597 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1598 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1599 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1600 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1601 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1602 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1603 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1604 default: rtype = NULL;
1605 }
1606
1607 if (rtype)
1608 printf (" (%s)", rtype);
1609 else
1610 {
1611 putchar (' ');
1612 printf (_("<unknown addend: %lx>"),
1613 (unsigned long) rels[i].r_addend);
1614 res = FALSE;
1615 }
1616 }
1617 else if (symtab_index)
1618 {
1619 if (symtab == NULL || symtab_index >= nsyms)
1620 {
1621 error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index);
1622 res = FALSE;
1623 }
1624 else
1625 {
1626 Elf_Internal_Sym * psym;
1627 const char * version_string;
1628 enum versioned_symbol_info sym_info;
1629 unsigned short vna_other;
1630
1631 psym = symtab + symtab_index;
1632
1633 version_string
1634 = get_symbol_version_string (filedata, is_dynsym,
1635 strtab, strtablen,
1636 symtab_index,
1637 psym,
1638 &sym_info,
1639 &vna_other);
1640
1641 printf (" ");
1642
1643 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1644 {
1645 const char * name;
1646 unsigned int len;
1647 unsigned int width = is_32bit_elf ? 8 : 14;
1648
1649 /* Relocations against GNU_IFUNC symbols do not use the value
1650 of the symbol as the address to relocate against. Instead
1651 they invoke the function named by the symbol and use its
1652 result as the address for relocation.
1653
1654 To indicate this to the user, do not display the value of
1655 the symbol in the "Symbols's Value" field. Instead show
1656 its name followed by () as a hint that the symbol is
1657 invoked. */
1658
1659 if (strtab == NULL
1660 || psym->st_name == 0
1661 || psym->st_name >= strtablen)
1662 name = "??";
1663 else
1664 name = strtab + psym->st_name;
1665
1666 len = print_symbol (width, name);
1667 if (version_string)
1668 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1669 version_string);
1670 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1671 }
1672 else
1673 {
1674 print_vma (psym->st_value, LONG_HEX);
1675
1676 printf (is_32bit_elf ? " " : " ");
1677 }
1678
1679 if (psym->st_name == 0)
1680 {
1681 const char * sec_name = "<null>";
1682 char name_buf[40];
1683
1684 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1685 {
1686 if (psym->st_shndx < filedata->file_header.e_shnum)
1687 sec_name = SECTION_NAME (filedata->section_headers + psym->st_shndx);
1688 else if (psym->st_shndx == SHN_ABS)
1689 sec_name = "ABS";
1690 else if (psym->st_shndx == SHN_COMMON)
1691 sec_name = "COMMON";
1692 else if ((filedata->file_header.e_machine == EM_MIPS
1693 && psym->st_shndx == SHN_MIPS_SCOMMON)
1694 || (filedata->file_header.e_machine == EM_TI_C6000
1695 && psym->st_shndx == SHN_TIC6X_SCOMMON))
1696 sec_name = "SCOMMON";
1697 else if (filedata->file_header.e_machine == EM_MIPS
1698 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1699 sec_name = "SUNDEF";
1700 else if ((filedata->file_header.e_machine == EM_X86_64
1701 || filedata->file_header.e_machine == EM_L1OM
1702 || filedata->file_header.e_machine == EM_K1OM)
1703 && psym->st_shndx == SHN_X86_64_LCOMMON)
1704 sec_name = "LARGE_COMMON";
1705 else if (filedata->file_header.e_machine == EM_IA_64
1706 && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1707 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1708 sec_name = "ANSI_COM";
1709 else if (is_ia64_vms (filedata)
1710 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1711 sec_name = "VMS_SYMVEC";
1712 else
1713 {
1714 sprintf (name_buf, "<section 0x%x>",
1715 (unsigned int) psym->st_shndx);
1716 sec_name = name_buf;
1717 }
1718 }
1719 print_symbol (22, sec_name);
1720 }
1721 else if (strtab == NULL)
1722 printf (_("<string table index: %3ld>"), psym->st_name);
1723 else if (psym->st_name >= strtablen)
1724 {
1725 error (_("<corrupt string table index: %3ld>"), psym->st_name);
1726 res = FALSE;
1727 }
1728 else
1729 {
1730 print_symbol (22, strtab + psym->st_name);
1731 if (version_string)
1732 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1733 version_string);
1734 }
1735
1736 if (is_rela)
1737 {
1738 bfd_vma off = rels[i].r_addend;
1739
1740 if ((bfd_signed_vma) off < 0)
1741 printf (" - %" BFD_VMA_FMT "x", - off);
1742 else
1743 printf (" + %" BFD_VMA_FMT "x", off);
1744 }
1745 }
1746 }
1747 else if (is_rela)
1748 {
1749 bfd_vma off = rels[i].r_addend;
1750
1751 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1752 if ((bfd_signed_vma) off < 0)
1753 printf ("-%" BFD_VMA_FMT "x", - off);
1754 else
1755 printf ("%" BFD_VMA_FMT "x", off);
1756 }
1757
1758 if (filedata->file_header.e_machine == EM_SPARCV9
1759 && rtype != NULL
1760 && streq (rtype, "R_SPARC_OLO10"))
1761 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1762
1763 putchar ('\n');
1764
1765 #ifdef BFD64
1766 if (! is_32bit_elf && filedata->file_header.e_machine == EM_MIPS)
1767 {
1768 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1769 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1770 const char * rtype2 = elf_mips_reloc_type (type2);
1771 const char * rtype3 = elf_mips_reloc_type (type3);
1772
1773 printf (" Type2: ");
1774
1775 if (rtype2 == NULL)
1776 printf (_("unrecognized: %-7lx"),
1777 (unsigned long) type2 & 0xffffffff);
1778 else
1779 printf ("%-17.17s", rtype2);
1780
1781 printf ("\n Type3: ");
1782
1783 if (rtype3 == NULL)
1784 printf (_("unrecognized: %-7lx"),
1785 (unsigned long) type3 & 0xffffffff);
1786 else
1787 printf ("%-17.17s", rtype3);
1788
1789 putchar ('\n');
1790 }
1791 #endif /* BFD64 */
1792 }
1793
1794 free (rels);
1795
1796 return res;
1797 }
1798
1799 static const char *
1800 get_mips_dynamic_type (unsigned long type)
1801 {
1802 switch (type)
1803 {
1804 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1805 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1806 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1807 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1808 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1809 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1810 case DT_MIPS_MSYM: return "MIPS_MSYM";
1811 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1812 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1813 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1814 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1815 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1816 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1817 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1818 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1819 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1820 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1821 case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
1822 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1823 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1824 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1825 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1826 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1827 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1828 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1829 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1830 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1831 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1832 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1833 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1834 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1835 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1836 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1837 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1838 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1839 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1840 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1841 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1842 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1843 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1844 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1845 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1846 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1847 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1848 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1849 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1850 default:
1851 return NULL;
1852 }
1853 }
1854
1855 static const char *
1856 get_sparc64_dynamic_type (unsigned long type)
1857 {
1858 switch (type)
1859 {
1860 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1861 default:
1862 return NULL;
1863 }
1864 }
1865
1866 static const char *
1867 get_ppc_dynamic_type (unsigned long type)
1868 {
1869 switch (type)
1870 {
1871 case DT_PPC_GOT: return "PPC_GOT";
1872 case DT_PPC_OPT: return "PPC_OPT";
1873 default:
1874 return NULL;
1875 }
1876 }
1877
1878 static const char *
1879 get_ppc64_dynamic_type (unsigned long type)
1880 {
1881 switch (type)
1882 {
1883 case DT_PPC64_GLINK: return "PPC64_GLINK";
1884 case DT_PPC64_OPD: return "PPC64_OPD";
1885 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1886 case DT_PPC64_OPT: return "PPC64_OPT";
1887 default:
1888 return NULL;
1889 }
1890 }
1891
1892 static const char *
1893 get_parisc_dynamic_type (unsigned long type)
1894 {
1895 switch (type)
1896 {
1897 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1898 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1899 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1900 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1901 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1902 case DT_HP_PREINIT: return "HP_PREINIT";
1903 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1904 case DT_HP_NEEDED: return "HP_NEEDED";
1905 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1906 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1907 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1908 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1909 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1910 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1911 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1912 case DT_HP_FILTERED: return "HP_FILTERED";
1913 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1914 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1915 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1916 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1917 case DT_PLT: return "PLT";
1918 case DT_PLT_SIZE: return "PLT_SIZE";
1919 case DT_DLT: return "DLT";
1920 case DT_DLT_SIZE: return "DLT_SIZE";
1921 default:
1922 return NULL;
1923 }
1924 }
1925
1926 static const char *
1927 get_ia64_dynamic_type (unsigned long type)
1928 {
1929 switch (type)
1930 {
1931 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1932 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1933 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1934 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1935 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1936 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1937 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1938 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1939 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1940 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1941 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1942 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1943 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1944 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1945 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1946 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1947 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1948 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1949 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1950 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1951 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1952 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1953 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1954 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1955 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1956 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1957 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1958 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1959 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1960 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1961 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
1962 default:
1963 return NULL;
1964 }
1965 }
1966
1967 static const char *
1968 get_solaris_section_type (unsigned long type)
1969 {
1970 switch (type)
1971 {
1972 case 0x6fffffee: return "SUNW_ancillary";
1973 case 0x6fffffef: return "SUNW_capchain";
1974 case 0x6ffffff0: return "SUNW_capinfo";
1975 case 0x6ffffff1: return "SUNW_symsort";
1976 case 0x6ffffff2: return "SUNW_tlssort";
1977 case 0x6ffffff3: return "SUNW_LDYNSYM";
1978 case 0x6ffffff4: return "SUNW_dof";
1979 case 0x6ffffff5: return "SUNW_cap";
1980 case 0x6ffffff6: return "SUNW_SIGNATURE";
1981 case 0x6ffffff7: return "SUNW_ANNOTATE";
1982 case 0x6ffffff8: return "SUNW_DEBUGSTR";
1983 case 0x6ffffff9: return "SUNW_DEBUG";
1984 case 0x6ffffffa: return "SUNW_move";
1985 case 0x6ffffffb: return "SUNW_COMDAT";
1986 case 0x6ffffffc: return "SUNW_syminfo";
1987 case 0x6ffffffd: return "SUNW_verdef";
1988 case 0x6ffffffe: return "SUNW_verneed";
1989 case 0x6fffffff: return "SUNW_versym";
1990 case 0x70000000: return "SPARC_GOTDATA";
1991 default: return NULL;
1992 }
1993 }
1994
1995 static const char *
1996 get_alpha_dynamic_type (unsigned long type)
1997 {
1998 switch (type)
1999 {
2000 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
2001 default: return NULL;
2002 }
2003 }
2004
2005 static const char *
2006 get_score_dynamic_type (unsigned long type)
2007 {
2008 switch (type)
2009 {
2010 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
2011 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
2012 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
2013 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
2014 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
2015 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
2016 default: return NULL;
2017 }
2018 }
2019
2020 static const char *
2021 get_tic6x_dynamic_type (unsigned long type)
2022 {
2023 switch (type)
2024 {
2025 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
2026 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
2027 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
2028 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
2029 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
2030 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
2031 default: return NULL;
2032 }
2033 }
2034
2035 static const char *
2036 get_nios2_dynamic_type (unsigned long type)
2037 {
2038 switch (type)
2039 {
2040 case DT_NIOS2_GP: return "NIOS2_GP";
2041 default: return NULL;
2042 }
2043 }
2044
2045 static const char *
2046 get_solaris_dynamic_type (unsigned long type)
2047 {
2048 switch (type)
2049 {
2050 case 0x6000000d: return "SUNW_AUXILIARY";
2051 case 0x6000000e: return "SUNW_RTLDINF";
2052 case 0x6000000f: return "SUNW_FILTER";
2053 case 0x60000010: return "SUNW_CAP";
2054 case 0x60000011: return "SUNW_SYMTAB";
2055 case 0x60000012: return "SUNW_SYMSZ";
2056 case 0x60000013: return "SUNW_SORTENT";
2057 case 0x60000014: return "SUNW_SYMSORT";
2058 case 0x60000015: return "SUNW_SYMSORTSZ";
2059 case 0x60000016: return "SUNW_TLSSORT";
2060 case 0x60000017: return "SUNW_TLSSORTSZ";
2061 case 0x60000018: return "SUNW_CAPINFO";
2062 case 0x60000019: return "SUNW_STRPAD";
2063 case 0x6000001a: return "SUNW_CAPCHAIN";
2064 case 0x6000001b: return "SUNW_LDMACH";
2065 case 0x6000001d: return "SUNW_CAPCHAINENT";
2066 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2067 case 0x60000021: return "SUNW_PARENT";
2068 case 0x60000023: return "SUNW_ASLR";
2069 case 0x60000025: return "SUNW_RELAX";
2070 case 0x60000029: return "SUNW_NXHEAP";
2071 case 0x6000002b: return "SUNW_NXSTACK";
2072
2073 case 0x70000001: return "SPARC_REGISTER";
2074 case 0x7ffffffd: return "AUXILIARY";
2075 case 0x7ffffffe: return "USED";
2076 case 0x7fffffff: return "FILTER";
2077
2078 default: return NULL;
2079 }
2080 }
2081
2082 static const char *
2083 get_dynamic_type (Filedata * filedata, unsigned long type)
2084 {
2085 static char buff[64];
2086
2087 switch (type)
2088 {
2089 case DT_NULL: return "NULL";
2090 case DT_NEEDED: return "NEEDED";
2091 case DT_PLTRELSZ: return "PLTRELSZ";
2092 case DT_PLTGOT: return "PLTGOT";
2093 case DT_HASH: return "HASH";
2094 case DT_STRTAB: return "STRTAB";
2095 case DT_SYMTAB: return "SYMTAB";
2096 case DT_RELA: return "RELA";
2097 case DT_RELASZ: return "RELASZ";
2098 case DT_RELAENT: return "RELAENT";
2099 case DT_STRSZ: return "STRSZ";
2100 case DT_SYMENT: return "SYMENT";
2101 case DT_INIT: return "INIT";
2102 case DT_FINI: return "FINI";
2103 case DT_SONAME: return "SONAME";
2104 case DT_RPATH: return "RPATH";
2105 case DT_SYMBOLIC: return "SYMBOLIC";
2106 case DT_REL: return "REL";
2107 case DT_RELSZ: return "RELSZ";
2108 case DT_RELENT: return "RELENT";
2109 case DT_PLTREL: return "PLTREL";
2110 case DT_DEBUG: return "DEBUG";
2111 case DT_TEXTREL: return "TEXTREL";
2112 case DT_JMPREL: return "JMPREL";
2113 case DT_BIND_NOW: return "BIND_NOW";
2114 case DT_INIT_ARRAY: return "INIT_ARRAY";
2115 case DT_FINI_ARRAY: return "FINI_ARRAY";
2116 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
2117 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
2118 case DT_RUNPATH: return "RUNPATH";
2119 case DT_FLAGS: return "FLAGS";
2120
2121 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2122 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
2123 case DT_SYMTAB_SHNDX: return "SYMTAB_SHNDX";
2124
2125 case DT_CHECKSUM: return "CHECKSUM";
2126 case DT_PLTPADSZ: return "PLTPADSZ";
2127 case DT_MOVEENT: return "MOVEENT";
2128 case DT_MOVESZ: return "MOVESZ";
2129 case DT_FEATURE: return "FEATURE";
2130 case DT_POSFLAG_1: return "POSFLAG_1";
2131 case DT_SYMINSZ: return "SYMINSZ";
2132 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
2133
2134 case DT_ADDRRNGLO: return "ADDRRNGLO";
2135 case DT_CONFIG: return "CONFIG";
2136 case DT_DEPAUDIT: return "DEPAUDIT";
2137 case DT_AUDIT: return "AUDIT";
2138 case DT_PLTPAD: return "PLTPAD";
2139 case DT_MOVETAB: return "MOVETAB";
2140 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
2141
2142 case DT_VERSYM: return "VERSYM";
2143
2144 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
2145 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
2146 case DT_RELACOUNT: return "RELACOUNT";
2147 case DT_RELCOUNT: return "RELCOUNT";
2148 case DT_FLAGS_1: return "FLAGS_1";
2149 case DT_VERDEF: return "VERDEF";
2150 case DT_VERDEFNUM: return "VERDEFNUM";
2151 case DT_VERNEED: return "VERNEED";
2152 case DT_VERNEEDNUM: return "VERNEEDNUM";
2153
2154 case DT_AUXILIARY: return "AUXILIARY";
2155 case DT_USED: return "USED";
2156 case DT_FILTER: return "FILTER";
2157
2158 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
2159 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
2160 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
2161 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
2162 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
2163 case DT_GNU_HASH: return "GNU_HASH";
2164
2165 default:
2166 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
2167 {
2168 const char * result;
2169
2170 switch (filedata->file_header.e_machine)
2171 {
2172 case EM_MIPS:
2173 case EM_MIPS_RS3_LE:
2174 result = get_mips_dynamic_type (type);
2175 break;
2176 case EM_SPARCV9:
2177 result = get_sparc64_dynamic_type (type);
2178 break;
2179 case EM_PPC:
2180 result = get_ppc_dynamic_type (type);
2181 break;
2182 case EM_PPC64:
2183 result = get_ppc64_dynamic_type (type);
2184 break;
2185 case EM_IA_64:
2186 result = get_ia64_dynamic_type (type);
2187 break;
2188 case EM_ALPHA:
2189 result = get_alpha_dynamic_type (type);
2190 break;
2191 case EM_SCORE:
2192 result = get_score_dynamic_type (type);
2193 break;
2194 case EM_TI_C6000:
2195 result = get_tic6x_dynamic_type (type);
2196 break;
2197 case EM_ALTERA_NIOS2:
2198 result = get_nios2_dynamic_type (type);
2199 break;
2200 default:
2201 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2202 result = get_solaris_dynamic_type (type);
2203 else
2204 result = NULL;
2205 break;
2206 }
2207
2208 if (result != NULL)
2209 return result;
2210
2211 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2212 }
2213 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2214 || (filedata->file_header.e_machine == EM_PARISC
2215 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
2216 {
2217 const char * result;
2218
2219 switch (filedata->file_header.e_machine)
2220 {
2221 case EM_PARISC:
2222 result = get_parisc_dynamic_type (type);
2223 break;
2224 case EM_IA_64:
2225 result = get_ia64_dynamic_type (type);
2226 break;
2227 default:
2228 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2229 result = get_solaris_dynamic_type (type);
2230 else
2231 result = NULL;
2232 break;
2233 }
2234
2235 if (result != NULL)
2236 return result;
2237
2238 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2239 type);
2240 }
2241 else
2242 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2243
2244 return buff;
2245 }
2246 }
2247
2248 static char *
2249 get_file_type (unsigned e_type)
2250 {
2251 static char buff[32];
2252
2253 switch (e_type)
2254 {
2255 case ET_NONE: return _("NONE (None)");
2256 case ET_REL: return _("REL (Relocatable file)");
2257 case ET_EXEC: return _("EXEC (Executable file)");
2258 case ET_DYN: return _("DYN (Shared object file)");
2259 case ET_CORE: return _("CORE (Core file)");
2260
2261 default:
2262 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2263 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2264 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2265 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2266 else
2267 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2268 return buff;
2269 }
2270 }
2271
2272 static char *
2273 get_machine_name (unsigned e_machine)
2274 {
2275 static char buff[64]; /* XXX */
2276
2277 switch (e_machine)
2278 {
2279 /* Please keep this switch table sorted by increasing EM_ value. */
2280 /* 0 */
2281 case EM_NONE: return _("None");
2282 case EM_M32: return "WE32100";
2283 case EM_SPARC: return "Sparc";
2284 case EM_386: return "Intel 80386";
2285 case EM_68K: return "MC68000";
2286 case EM_88K: return "MC88000";
2287 case EM_IAMCU: return "Intel MCU";
2288 case EM_860: return "Intel 80860";
2289 case EM_MIPS: return "MIPS R3000";
2290 case EM_S370: return "IBM System/370";
2291 /* 10 */
2292 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
2293 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
2294 case EM_PARISC: return "HPPA";
2295 case EM_VPP550: return "Fujitsu VPP500";
2296 case EM_SPARC32PLUS: return "Sparc v8+" ;
2297 case EM_960: return "Intel 80960";
2298 case EM_PPC: return "PowerPC";
2299 /* 20 */
2300 case EM_PPC64: return "PowerPC64";
2301 case EM_S390_OLD:
2302 case EM_S390: return "IBM S/390";
2303 case EM_SPU: return "SPU";
2304 /* 30 */
2305 case EM_V800: return "Renesas V850 (using RH850 ABI)";
2306 case EM_FR20: return "Fujitsu FR20";
2307 case EM_RH32: return "TRW RH32";
2308 case EM_MCORE: return "MCORE";
2309 /* 40 */
2310 case EM_ARM: return "ARM";
2311 case EM_OLD_ALPHA: return "Digital Alpha (old)";
2312 case EM_SH: return "Renesas / SuperH SH";
2313 case EM_SPARCV9: return "Sparc v9";
2314 case EM_TRICORE: return "Siemens Tricore";
2315 case EM_ARC: return "ARC";
2316 case EM_H8_300: return "Renesas H8/300";
2317 case EM_H8_300H: return "Renesas H8/300H";
2318 case EM_H8S: return "Renesas H8S";
2319 case EM_H8_500: return "Renesas H8/500";
2320 /* 50 */
2321 case EM_IA_64: return "Intel IA-64";
2322 case EM_MIPS_X: return "Stanford MIPS-X";
2323 case EM_COLDFIRE: return "Motorola Coldfire";
2324 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
2325 case EM_MMA: return "Fujitsu Multimedia Accelerator";
2326 case EM_PCP: return "Siemens PCP";
2327 case EM_NCPU: return "Sony nCPU embedded RISC processor";
2328 case EM_NDR1: return "Denso NDR1 microprocesspr";
2329 case EM_STARCORE: return "Motorola Star*Core processor";
2330 case EM_ME16: return "Toyota ME16 processor";
2331 /* 60 */
2332 case EM_ST100: return "STMicroelectronics ST100 processor";
2333 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
2334 case EM_X86_64: return "Advanced Micro Devices X86-64";
2335 case EM_PDSP: return "Sony DSP processor";
2336 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
2337 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
2338 case EM_FX66: return "Siemens FX66 microcontroller";
2339 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2340 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
2341 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
2342 /* 70 */
2343 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
2344 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
2345 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
2346 case EM_SVX: return "Silicon Graphics SVx";
2347 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2348 case EM_VAX: return "Digital VAX";
2349 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
2350 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2351 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2352 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
2353 /* 80 */
2354 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
2355 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
2356 case EM_PRISM: return "Vitesse Prism";
2357 case EM_AVR_OLD:
2358 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
2359 case EM_CYGNUS_FR30:
2360 case EM_FR30: return "Fujitsu FR30";
2361 case EM_CYGNUS_D10V:
2362 case EM_D10V: return "d10v";
2363 case EM_CYGNUS_D30V:
2364 case EM_D30V: return "d30v";
2365 case EM_CYGNUS_V850:
2366 case EM_V850: return "Renesas V850";
2367 case EM_CYGNUS_M32R:
2368 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2369 case EM_CYGNUS_MN10300:
2370 case EM_MN10300: return "mn10300";
2371 /* 90 */
2372 case EM_CYGNUS_MN10200:
2373 case EM_MN10200: return "mn10200";
2374 case EM_PJ: return "picoJava";
2375 case EM_OR1K: return "OpenRISC 1000";
2376 case EM_ARC_COMPACT: return "ARCompact";
2377 case EM_XTENSA_OLD:
2378 case EM_XTENSA: return "Tensilica Xtensa Processor";
2379 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2380 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2381 case EM_NS32K: return "National Semiconductor 32000 series";
2382 case EM_TPC: return "Tenor Network TPC processor";
2383 case EM_SNP1K: return "Trebia SNP 1000 processor";
2384 /* 100 */
2385 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2386 case EM_IP2K_OLD:
2387 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
2388 case EM_MAX: return "MAX Processor";
2389 case EM_CR: return "National Semiconductor CompactRISC";
2390 case EM_F2MC16: return "Fujitsu F2MC16";
2391 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
2392 case EM_BLACKFIN: return "Analog Devices Blackfin";
2393 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2394 case EM_SEP: return "Sharp embedded microprocessor";
2395 case EM_ARCA: return "Arca RISC microprocessor";
2396 /* 110 */
2397 case EM_UNICORE: return "Unicore";
2398 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2399 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
2400 case EM_ALTERA_NIOS2: return "Altera Nios II";
2401 case EM_CRX: return "National Semiconductor CRX microprocessor";
2402 case EM_XGATE: return "Motorola XGATE embedded processor";
2403 case EM_C166:
2404 case EM_XC16X: return "Infineon Technologies xc16x";
2405 case EM_M16C: return "Renesas M16C series microprocessors";
2406 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2407 case EM_CE: return "Freescale Communication Engine RISC core";
2408 /* 120 */
2409 case EM_M32C: return "Renesas M32c";
2410 /* 130 */
2411 case EM_TSK3000: return "Altium TSK3000 core";
2412 case EM_RS08: return "Freescale RS08 embedded processor";
2413 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2414 case EM_SCORE: return "SUNPLUS S+Core";
2415 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2416 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2417 case EM_LATTICEMICO32: return "Lattice Mico32";
2418 case EM_SE_C17: return "Seiko Epson C17 family";
2419 /* 140 */
2420 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2421 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2422 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2423 case EM_TI_PRU: return "TI PRU I/O processor";
2424 /* 160 */
2425 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2426 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2427 case EM_R32C: return "Renesas R32C series microprocessors";
2428 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2429 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2430 case EM_8051: return "Intel 8051 and variants";
2431 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2432 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2433 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2434 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2435 /* 170 */
2436 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2437 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2438 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
2439 case EM_RX: return "Renesas RX";
2440 case EM_METAG: return "Imagination Technologies Meta processor architecture";
2441 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2442 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2443 case EM_CR16:
2444 case EM_MICROBLAZE:
2445 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
2446 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2447 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2448 /* 180 */
2449 case EM_L1OM: return "Intel L1OM";
2450 case EM_K1OM: return "Intel K1OM";
2451 case EM_INTEL182: return "Intel (reserved)";
2452 case EM_AARCH64: return "AArch64";
2453 case EM_ARM184: return "ARM (reserved)";
2454 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor";
2455 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2456 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2457 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
2458 /* 190 */
2459 case EM_CUDA: return "NVIDIA CUDA architecture";
2460 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
2461 case EM_CLOUDSHIELD: return "CloudShield architecture family";
2462 case EM_COREA_1ST: return "KIPO-KAIST Core-A 1st generation processor family";
2463 case EM_COREA_2ND: return "KIPO-KAIST Core-A 2nd generation processor family";
2464 case EM_ARC_COMPACT2: return "ARCv2";
2465 case EM_OPEN8: return "Open8 8-bit RISC soft processor core";
2466 case EM_RL78: return "Renesas RL78";
2467 case EM_VIDEOCORE5: return "Broadcom VideoCore V processor";
2468 case EM_78K0R: return "Renesas 78K0R";
2469 /* 200 */
2470 case EM_56800EX: return "Freescale 56800EX Digital Signal Controller (DSC)";
2471 case EM_BA1: return "Beyond BA1 CPU architecture";
2472 case EM_BA2: return "Beyond BA2 CPU architecture";
2473 case EM_XCORE: return "XMOS xCORE processor family";
2474 case EM_MCHP_PIC: return "Microchip 8-bit PIC(r) family";
2475 /* 210 */
2476 case EM_KM32: return "KM211 KM32 32-bit processor";
2477 case EM_KMX32: return "KM211 KMX32 32-bit processor";
2478 case EM_KMX16: return "KM211 KMX16 16-bit processor";
2479 case EM_KMX8: return "KM211 KMX8 8-bit processor";
2480 case EM_KVARC: return "KM211 KVARC processor";
2481 case EM_CDP: return "Paneve CDP architecture family";
2482 case EM_COGE: return "Cognitive Smart Memory Processor";
2483 case EM_COOL: return "Bluechip Systems CoolEngine";
2484 case EM_NORC: return "Nanoradio Optimized RISC";
2485 case EM_CSR_KALIMBA: return "CSR Kalimba architecture family";
2486 /* 220 */
2487 case EM_Z80: return "Zilog Z80";
2488 case EM_VISIUM: return "CDS VISIUMcore processor";
2489 case EM_FT32: return "FTDI Chip FT32";
2490 case EM_MOXIE: return "Moxie";
2491 case EM_AMDGPU: return "AMD GPU";
2492 case EM_RISCV: return "RISC-V";
2493 case EM_LANAI: return "Lanai 32-bit processor";
2494 case EM_BPF: return "Linux BPF";
2495 case EM_NFP: return "Netronome Flow Processor";
2496
2497 /* Large numbers... */
2498 case EM_MT: return "Morpho Techologies MT processor";
2499 case EM_ALPHA: return "Alpha";
2500 case EM_WEBASSEMBLY: return "Web Assembly";
2501 case EM_DLX: return "OpenDLX";
2502 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
2503 case EM_IQ2000: return "Vitesse IQ2000";
2504 case EM_M32C_OLD:
2505 case EM_NIOS32: return "Altera Nios";
2506 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
2507 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
2508 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2509 case EM_S12Z: return "Freescale S12Z";
2510 case EM_CSKY: return "C-SKY";
2511
2512 default:
2513 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2514 return buff;
2515 }
2516 }
2517
2518 static void
2519 decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
2520 {
2521 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2522 other compilers don't a specific architecture type in the e_flags, and
2523 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2524 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2525 architectures.
2526
2527 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2528 but also sets a specific architecture type in the e_flags field.
2529
2530 However, when decoding the flags we don't worry if we see an
2531 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2532 ARCEM architecture type. */
2533
2534 switch (e_flags & EF_ARC_MACH_MSK)
2535 {
2536 /* We only expect these to occur for EM_ARC_COMPACT2. */
2537 case EF_ARC_CPU_ARCV2EM:
2538 strcat (buf, ", ARC EM");
2539 break;
2540 case EF_ARC_CPU_ARCV2HS:
2541 strcat (buf, ", ARC HS");
2542 break;
2543
2544 /* We only expect these to occur for EM_ARC_COMPACT. */
2545 case E_ARC_MACH_ARC600:
2546 strcat (buf, ", ARC600");
2547 break;
2548 case E_ARC_MACH_ARC601:
2549 strcat (buf, ", ARC601");
2550 break;
2551 case E_ARC_MACH_ARC700:
2552 strcat (buf, ", ARC700");
2553 break;
2554
2555 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2556 new ELF with new architecture being read by an old version of
2557 readelf, or (c) An ELF built with non-GNU compiler that does not
2558 set the architecture in the e_flags. */
2559 default:
2560 if (e_machine == EM_ARC_COMPACT)
2561 strcat (buf, ", Unknown ARCompact");
2562 else
2563 strcat (buf, ", Unknown ARC");
2564 break;
2565 }
2566
2567 switch (e_flags & EF_ARC_OSABI_MSK)
2568 {
2569 case E_ARC_OSABI_ORIG:
2570 strcat (buf, ", (ABI:legacy)");
2571 break;
2572 case E_ARC_OSABI_V2:
2573 strcat (buf, ", (ABI:v2)");
2574 break;
2575 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2576 case E_ARC_OSABI_V3:
2577 strcat (buf, ", v3 no-legacy-syscalls ABI");
2578 break;
2579 case E_ARC_OSABI_V4:
2580 strcat (buf, ", v4 ABI");
2581 break;
2582 default:
2583 strcat (buf, ", unrecognised ARC OSABI flag");
2584 break;
2585 }
2586 }
2587
2588 static void
2589 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2590 {
2591 unsigned eabi;
2592 bfd_boolean unknown = FALSE;
2593
2594 eabi = EF_ARM_EABI_VERSION (e_flags);
2595 e_flags &= ~ EF_ARM_EABIMASK;
2596
2597 /* Handle "generic" ARM flags. */
2598 if (e_flags & EF_ARM_RELEXEC)
2599 {
2600 strcat (buf, ", relocatable executable");
2601 e_flags &= ~ EF_ARM_RELEXEC;
2602 }
2603
2604 if (e_flags & EF_ARM_PIC)
2605 {
2606 strcat (buf, ", position independent");
2607 e_flags &= ~ EF_ARM_PIC;
2608 }
2609
2610 /* Now handle EABI specific flags. */
2611 switch (eabi)
2612 {
2613 default:
2614 strcat (buf, ", <unrecognized EABI>");
2615 if (e_flags)
2616 unknown = TRUE;
2617 break;
2618
2619 case EF_ARM_EABI_VER1:
2620 strcat (buf, ", Version1 EABI");
2621 while (e_flags)
2622 {
2623 unsigned flag;
2624
2625 /* Process flags one bit at a time. */
2626 flag = e_flags & - e_flags;
2627 e_flags &= ~ flag;
2628
2629 switch (flag)
2630 {
2631 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2632 strcat (buf, ", sorted symbol tables");
2633 break;
2634
2635 default:
2636 unknown = TRUE;
2637 break;
2638 }
2639 }
2640 break;
2641
2642 case EF_ARM_EABI_VER2:
2643 strcat (buf, ", Version2 EABI");
2644 while (e_flags)
2645 {
2646 unsigned flag;
2647
2648 /* Process flags one bit at a time. */
2649 flag = e_flags & - e_flags;
2650 e_flags &= ~ flag;
2651
2652 switch (flag)
2653 {
2654 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2655 strcat (buf, ", sorted symbol tables");
2656 break;
2657
2658 case EF_ARM_DYNSYMSUSESEGIDX:
2659 strcat (buf, ", dynamic symbols use segment index");
2660 break;
2661
2662 case EF_ARM_MAPSYMSFIRST:
2663 strcat (buf, ", mapping symbols precede others");
2664 break;
2665
2666 default:
2667 unknown = TRUE;
2668 break;
2669 }
2670 }
2671 break;
2672
2673 case EF_ARM_EABI_VER3:
2674 strcat (buf, ", Version3 EABI");
2675 break;
2676
2677 case EF_ARM_EABI_VER4:
2678 strcat (buf, ", Version4 EABI");
2679 while (e_flags)
2680 {
2681 unsigned flag;
2682
2683 /* Process flags one bit at a time. */
2684 flag = e_flags & - e_flags;
2685 e_flags &= ~ flag;
2686
2687 switch (flag)
2688 {
2689 case EF_ARM_BE8:
2690 strcat (buf, ", BE8");
2691 break;
2692
2693 case EF_ARM_LE8:
2694 strcat (buf, ", LE8");
2695 break;
2696
2697 default:
2698 unknown = TRUE;
2699 break;
2700 }
2701 }
2702 break;
2703
2704 case EF_ARM_EABI_VER5:
2705 strcat (buf, ", Version5 EABI");
2706 while (e_flags)
2707 {
2708 unsigned flag;
2709
2710 /* Process flags one bit at a time. */
2711 flag = e_flags & - e_flags;
2712 e_flags &= ~ flag;
2713
2714 switch (flag)
2715 {
2716 case EF_ARM_BE8:
2717 strcat (buf, ", BE8");
2718 break;
2719
2720 case EF_ARM_LE8:
2721 strcat (buf, ", LE8");
2722 break;
2723
2724 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2725 strcat (buf, ", soft-float ABI");
2726 break;
2727
2728 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2729 strcat (buf, ", hard-float ABI");
2730 break;
2731
2732 default:
2733 unknown = TRUE;
2734 break;
2735 }
2736 }
2737 break;
2738
2739 case EF_ARM_EABI_UNKNOWN:
2740 strcat (buf, ", GNU EABI");
2741 while (e_flags)
2742 {
2743 unsigned flag;
2744
2745 /* Process flags one bit at a time. */
2746 flag = e_flags & - e_flags;
2747 e_flags &= ~ flag;
2748
2749 switch (flag)
2750 {
2751 case EF_ARM_INTERWORK:
2752 strcat (buf, ", interworking enabled");
2753 break;
2754
2755 case EF_ARM_APCS_26:
2756 strcat (buf, ", uses APCS/26");
2757 break;
2758
2759 case EF_ARM_APCS_FLOAT:
2760 strcat (buf, ", uses APCS/float");
2761 break;
2762
2763 case EF_ARM_PIC:
2764 strcat (buf, ", position independent");
2765 break;
2766
2767 case EF_ARM_ALIGN8:
2768 strcat (buf, ", 8 bit structure alignment");
2769 break;
2770
2771 case EF_ARM_NEW_ABI:
2772 strcat (buf, ", uses new ABI");
2773 break;
2774
2775 case EF_ARM_OLD_ABI:
2776 strcat (buf, ", uses old ABI");
2777 break;
2778
2779 case EF_ARM_SOFT_FLOAT:
2780 strcat (buf, ", software FP");
2781 break;
2782
2783 case EF_ARM_VFP_FLOAT:
2784 strcat (buf, ", VFP");
2785 break;
2786
2787 case EF_ARM_MAVERICK_FLOAT:
2788 strcat (buf, ", Maverick FP");
2789 break;
2790
2791 default:
2792 unknown = TRUE;
2793 break;
2794 }
2795 }
2796 }
2797
2798 if (unknown)
2799 strcat (buf,_(", <unknown>"));
2800 }
2801
2802 static void
2803 decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2804 {
2805 --size; /* Leave space for null terminator. */
2806
2807 switch (e_flags & EF_AVR_MACH)
2808 {
2809 case E_AVR_MACH_AVR1:
2810 strncat (buf, ", avr:1", size);
2811 break;
2812 case E_AVR_MACH_AVR2:
2813 strncat (buf, ", avr:2", size);
2814 break;
2815 case E_AVR_MACH_AVR25:
2816 strncat (buf, ", avr:25", size);
2817 break;
2818 case E_AVR_MACH_AVR3:
2819 strncat (buf, ", avr:3", size);
2820 break;
2821 case E_AVR_MACH_AVR31:
2822 strncat (buf, ", avr:31", size);
2823 break;
2824 case E_AVR_MACH_AVR35:
2825 strncat (buf, ", avr:35", size);
2826 break;
2827 case E_AVR_MACH_AVR4:
2828 strncat (buf, ", avr:4", size);
2829 break;
2830 case E_AVR_MACH_AVR5:
2831 strncat (buf, ", avr:5", size);
2832 break;
2833 case E_AVR_MACH_AVR51:
2834 strncat (buf, ", avr:51", size);
2835 break;
2836 case E_AVR_MACH_AVR6:
2837 strncat (buf, ", avr:6", size);
2838 break;
2839 case E_AVR_MACH_AVRTINY:
2840 strncat (buf, ", avr:100", size);
2841 break;
2842 case E_AVR_MACH_XMEGA1:
2843 strncat (buf, ", avr:101", size);
2844 break;
2845 case E_AVR_MACH_XMEGA2:
2846 strncat (buf, ", avr:102", size);
2847 break;
2848 case E_AVR_MACH_XMEGA3:
2849 strncat (buf, ", avr:103", size);
2850 break;
2851 case E_AVR_MACH_XMEGA4:
2852 strncat (buf, ", avr:104", size);
2853 break;
2854 case E_AVR_MACH_XMEGA5:
2855 strncat (buf, ", avr:105", size);
2856 break;
2857 case E_AVR_MACH_XMEGA6:
2858 strncat (buf, ", avr:106", size);
2859 break;
2860 case E_AVR_MACH_XMEGA7:
2861 strncat (buf, ", avr:107", size);
2862 break;
2863 default:
2864 strncat (buf, ", avr:<unknown>", size);
2865 break;
2866 }
2867
2868 size -= strlen (buf);
2869 if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2870 strncat (buf, ", link-relax", size);
2871 }
2872
2873 static void
2874 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2875 {
2876 unsigned abi;
2877 unsigned arch;
2878 unsigned config;
2879 unsigned version;
2880 bfd_boolean has_fpu = FALSE;
2881 unsigned int r = 0;
2882
2883 static const char *ABI_STRINGS[] =
2884 {
2885 "ABI v0", /* use r5 as return register; only used in N1213HC */
2886 "ABI v1", /* use r0 as return register */
2887 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2888 "ABI v2fp", /* for FPU */
2889 "AABI",
2890 "ABI2 FP+"
2891 };
2892 static const char *VER_STRINGS[] =
2893 {
2894 "Andes ELF V1.3 or older",
2895 "Andes ELF V1.3.1",
2896 "Andes ELF V1.4"
2897 };
2898 static const char *ARCH_STRINGS[] =
2899 {
2900 "",
2901 "Andes Star v1.0",
2902 "Andes Star v2.0",
2903 "Andes Star v3.0",
2904 "Andes Star v3.0m"
2905 };
2906
2907 abi = EF_NDS_ABI & e_flags;
2908 arch = EF_NDS_ARCH & e_flags;
2909 config = EF_NDS_INST & e_flags;
2910 version = EF_NDS32_ELF_VERSION & e_flags;
2911
2912 memset (buf, 0, size);
2913
2914 switch (abi)
2915 {
2916 case E_NDS_ABI_V0:
2917 case E_NDS_ABI_V1:
2918 case E_NDS_ABI_V2:
2919 case E_NDS_ABI_V2FP:
2920 case E_NDS_ABI_AABI:
2921 case E_NDS_ABI_V2FP_PLUS:
2922 /* In case there are holes in the array. */
2923 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2924 break;
2925
2926 default:
2927 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2928 break;
2929 }
2930
2931 switch (version)
2932 {
2933 case E_NDS32_ELF_VER_1_2:
2934 case E_NDS32_ELF_VER_1_3:
2935 case E_NDS32_ELF_VER_1_4:
2936 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2937 break;
2938
2939 default:
2940 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2941 break;
2942 }
2943
2944 if (E_NDS_ABI_V0 == abi)
2945 {
2946 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2947 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2948 if (arch == E_NDS_ARCH_STAR_V1_0)
2949 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2950 return;
2951 }
2952
2953 switch (arch)
2954 {
2955 case E_NDS_ARCH_STAR_V1_0:
2956 case E_NDS_ARCH_STAR_V2_0:
2957 case E_NDS_ARCH_STAR_V3_0:
2958 case E_NDS_ARCH_STAR_V3_M:
2959 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2960 break;
2961
2962 default:
2963 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2964 /* ARCH version determines how the e_flags are interpreted.
2965 If it is unknown, we cannot proceed. */
2966 return;
2967 }
2968
2969 /* Newer ABI; Now handle architecture specific flags. */
2970 if (arch == E_NDS_ARCH_STAR_V1_0)
2971 {
2972 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2973 r += snprintf (buf + r, size -r, ", MFUSR_PC");
2974
2975 if (!(config & E_NDS32_HAS_NO_MAC_INST))
2976 r += snprintf (buf + r, size -r, ", MAC");
2977
2978 if (config & E_NDS32_HAS_DIV_INST)
2979 r += snprintf (buf + r, size -r, ", DIV");
2980
2981 if (config & E_NDS32_HAS_16BIT_INST)
2982 r += snprintf (buf + r, size -r, ", 16b");
2983 }
2984 else
2985 {
2986 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2987 {
2988 if (version <= E_NDS32_ELF_VER_1_3)
2989 r += snprintf (buf + r, size -r, ", [B8]");
2990 else
2991 r += snprintf (buf + r, size -r, ", EX9");
2992 }
2993
2994 if (config & E_NDS32_HAS_MAC_DX_INST)
2995 r += snprintf (buf + r, size -r, ", MAC_DX");
2996
2997 if (config & E_NDS32_HAS_DIV_DX_INST)
2998 r += snprintf (buf + r, size -r, ", DIV_DX");
2999
3000 if (config & E_NDS32_HAS_16BIT_INST)
3001 {
3002 if (version <= E_NDS32_ELF_VER_1_3)
3003 r += snprintf (buf + r, size -r, ", 16b");
3004 else
3005 r += snprintf (buf + r, size -r, ", IFC");
3006 }
3007 }
3008
3009 if (config & E_NDS32_HAS_EXT_INST)
3010 r += snprintf (buf + r, size -r, ", PERF1");
3011
3012 if (config & E_NDS32_HAS_EXT2_INST)
3013 r += snprintf (buf + r, size -r, ", PERF2");
3014
3015 if (config & E_NDS32_HAS_FPU_INST)
3016 {
3017 has_fpu = TRUE;
3018 r += snprintf (buf + r, size -r, ", FPU_SP");
3019 }
3020
3021 if (config & E_NDS32_HAS_FPU_DP_INST)
3022 {
3023 has_fpu = TRUE;
3024 r += snprintf (buf + r, size -r, ", FPU_DP");
3025 }
3026
3027 if (config & E_NDS32_HAS_FPU_MAC_INST)
3028 {
3029 has_fpu = TRUE;
3030 r += snprintf (buf + r, size -r, ", FPU_MAC");
3031 }
3032
3033 if (has_fpu)
3034 {
3035 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
3036 {
3037 case E_NDS32_FPU_REG_8SP_4DP:
3038 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
3039 break;
3040 case E_NDS32_FPU_REG_16SP_8DP:
3041 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
3042 break;
3043 case E_NDS32_FPU_REG_32SP_16DP:
3044 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
3045 break;
3046 case E_NDS32_FPU_REG_32SP_32DP:
3047 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
3048 break;
3049 }
3050 }
3051
3052 if (config & E_NDS32_HAS_AUDIO_INST)
3053 r += snprintf (buf + r, size -r, ", AUDIO");
3054
3055 if (config & E_NDS32_HAS_STRING_INST)
3056 r += snprintf (buf + r, size -r, ", STR");
3057
3058 if (config & E_NDS32_HAS_REDUCED_REGS)
3059 r += snprintf (buf + r, size -r, ", 16REG");
3060
3061 if (config & E_NDS32_HAS_VIDEO_INST)
3062 {
3063 if (version <= E_NDS32_ELF_VER_1_3)
3064 r += snprintf (buf + r, size -r, ", VIDEO");
3065 else
3066 r += snprintf (buf + r, size -r, ", SATURATION");
3067 }
3068
3069 if (config & E_NDS32_HAS_ENCRIPT_INST)
3070 r += snprintf (buf + r, size -r, ", ENCRP");
3071
3072 if (config & E_NDS32_HAS_L2C_INST)
3073 r += snprintf (buf + r, size -r, ", L2C");
3074 }
3075
3076 static char *
3077 get_machine_flags (Filedata * filedata, unsigned e_flags, unsigned e_machine)
3078 {
3079 static char buf[1024];
3080
3081 buf[0] = '\0';
3082
3083 if (e_flags)
3084 {
3085 switch (e_machine)
3086 {
3087 default:
3088 break;
3089
3090 case EM_ARC_COMPACT2:
3091 case EM_ARC_COMPACT:
3092 decode_ARC_machine_flags (e_flags, e_machine, buf);
3093 break;
3094
3095 case EM_ARM:
3096 decode_ARM_machine_flags (e_flags, buf);
3097 break;
3098
3099 case EM_AVR:
3100 decode_AVR_machine_flags (e_flags, buf, sizeof buf);
3101 break;
3102
3103 case EM_BLACKFIN:
3104 if (e_flags & EF_BFIN_PIC)
3105 strcat (buf, ", PIC");
3106
3107 if (e_flags & EF_BFIN_FDPIC)
3108 strcat (buf, ", FDPIC");
3109
3110 if (e_flags & EF_BFIN_CODE_IN_L1)
3111 strcat (buf, ", code in L1");
3112
3113 if (e_flags & EF_BFIN_DATA_IN_L1)
3114 strcat (buf, ", data in L1");
3115
3116 break;
3117
3118 case EM_CYGNUS_FRV:
3119 switch (e_flags & EF_FRV_CPU_MASK)
3120 {
3121 case EF_FRV_CPU_GENERIC:
3122 break;
3123
3124 default:
3125 strcat (buf, ", fr???");
3126 break;
3127
3128 case EF_FRV_CPU_FR300:
3129 strcat (buf, ", fr300");
3130 break;
3131
3132 case EF_FRV_CPU_FR400:
3133 strcat (buf, ", fr400");
3134 break;
3135 case EF_FRV_CPU_FR405:
3136 strcat (buf, ", fr405");
3137 break;
3138
3139 case EF_FRV_CPU_FR450:
3140 strcat (buf, ", fr450");
3141 break;
3142
3143 case EF_FRV_CPU_FR500:
3144 strcat (buf, ", fr500");
3145 break;
3146 case EF_FRV_CPU_FR550:
3147 strcat (buf, ", fr550");
3148 break;
3149
3150 case EF_FRV_CPU_SIMPLE:
3151 strcat (buf, ", simple");
3152 break;
3153 case EF_FRV_CPU_TOMCAT:
3154 strcat (buf, ", tomcat");
3155 break;
3156 }
3157 break;
3158
3159 case EM_68K:
3160 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
3161 strcat (buf, ", m68000");
3162 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3163 strcat (buf, ", cpu32");
3164 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
3165 strcat (buf, ", fido_a");
3166 else
3167 {
3168 char const * isa = _("unknown");
3169 char const * mac = _("unknown mac");
3170 char const * additional = NULL;
3171
3172 switch (e_flags & EF_M68K_CF_ISA_MASK)
3173 {
3174 case EF_M68K_CF_ISA_A_NODIV:
3175 isa = "A";
3176 additional = ", nodiv";
3177 break;
3178 case EF_M68K_CF_ISA_A:
3179 isa = "A";
3180 break;
3181 case EF_M68K_CF_ISA_A_PLUS:
3182 isa = "A+";
3183 break;
3184 case EF_M68K_CF_ISA_B_NOUSP:
3185 isa = "B";
3186 additional = ", nousp";
3187 break;
3188 case EF_M68K_CF_ISA_B:
3189 isa = "B";
3190 break;
3191 case EF_M68K_CF_ISA_C:
3192 isa = "C";
3193 break;
3194 case EF_M68K_CF_ISA_C_NODIV:
3195 isa = "C";
3196 additional = ", nodiv";
3197 break;
3198 }
3199 strcat (buf, ", cf, isa ");
3200 strcat (buf, isa);
3201 if (additional)
3202 strcat (buf, additional);
3203 if (e_flags & EF_M68K_CF_FLOAT)
3204 strcat (buf, ", float");
3205 switch (e_flags & EF_M68K_CF_MAC_MASK)
3206 {
3207 case 0:
3208 mac = NULL;
3209 break;
3210 case EF_M68K_CF_MAC:
3211 mac = "mac";
3212 break;
3213 case EF_M68K_CF_EMAC:
3214 mac = "emac";
3215 break;
3216 case EF_M68K_CF_EMAC_B:
3217 mac = "emac_b";
3218 break;
3219 }
3220 if (mac)
3221 {
3222 strcat (buf, ", ");
3223 strcat (buf, mac);
3224 }
3225 }
3226 break;
3227
3228 case EM_CYGNUS_MEP:
3229 switch (e_flags & EF_MEP_CPU_MASK)
3230 {
3231 case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
3232 case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
3233 case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
3234 case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
3235 case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
3236 case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
3237 default: strcat (buf, _(", <unknown MeP cpu type>")); break;
3238 }
3239
3240 switch (e_flags & EF_MEP_COP_MASK)
3241 {
3242 case EF_MEP_COP_NONE: break;
3243 case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
3244 case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
3245 case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
3246 case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
3247 default: strcat (buf, _("<unknown MeP copro type>")); break;
3248 }
3249
3250 if (e_flags & EF_MEP_LIBRARY)
3251 strcat (buf, ", Built for Library");
3252
3253 if (e_flags & EF_MEP_INDEX_MASK)
3254 sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3255 e_flags & EF_MEP_INDEX_MASK);
3256
3257 if (e_flags & ~ EF_MEP_ALL_FLAGS)
3258 sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3259 e_flags & ~ EF_MEP_ALL_FLAGS);
3260 break;
3261
3262 case EM_PPC:
3263 if (e_flags & EF_PPC_EMB)
3264 strcat (buf, ", emb");
3265
3266 if (e_flags & EF_PPC_RELOCATABLE)
3267 strcat (buf, _(", relocatable"));
3268
3269 if (e_flags & EF_PPC_RELOCATABLE_LIB)
3270 strcat (buf, _(", relocatable-lib"));
3271 break;
3272
3273 case EM_PPC64:
3274 if (e_flags & EF_PPC64_ABI)
3275 {
3276 char abi[] = ", abiv0";
3277
3278 abi[6] += e_flags & EF_PPC64_ABI;
3279 strcat (buf, abi);
3280 }
3281 break;
3282
3283 case EM_V800:
3284 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3285 strcat (buf, ", RH850 ABI");
3286
3287 if (e_flags & EF_V800_850E3)
3288 strcat (buf, ", V3 architecture");
3289
3290 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3291 strcat (buf, ", FPU not used");
3292
3293 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3294 strcat (buf, ", regmode: COMMON");
3295
3296 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3297 strcat (buf, ", r4 not used");
3298
3299 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3300 strcat (buf, ", r30 not used");
3301
3302 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3303 strcat (buf, ", r5 not used");
3304
3305 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3306 strcat (buf, ", r2 not used");
3307
3308 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3309 {
3310 switch (e_flags & - e_flags)
3311 {
3312 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3313 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
3314 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3315 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
3316 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3317 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3318 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3319 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3320 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3321 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3322 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3323 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3324 default: break;
3325 }
3326 }
3327 break;
3328
3329 case EM_V850:
3330 case EM_CYGNUS_V850:
3331 switch (e_flags & EF_V850_ARCH)
3332 {
3333 case E_V850E3V5_ARCH:
3334 strcat (buf, ", v850e3v5");
3335 break;
3336 case E_V850E2V3_ARCH:
3337 strcat (buf, ", v850e2v3");
3338 break;
3339 case E_V850E2_ARCH:
3340 strcat (buf, ", v850e2");
3341 break;
3342 case E_V850E1_ARCH:
3343 strcat (buf, ", v850e1");
3344 break;
3345 case E_V850E_ARCH:
3346 strcat (buf, ", v850e");
3347 break;
3348 case E_V850_ARCH:
3349 strcat (buf, ", v850");
3350 break;
3351 default:
3352 strcat (buf, _(", unknown v850 architecture variant"));
3353 break;
3354 }
3355 break;
3356
3357 case EM_M32R:
3358 case EM_CYGNUS_M32R:
3359 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3360 strcat (buf, ", m32r");
3361 break;
3362
3363 case EM_MIPS:
3364 case EM_MIPS_RS3_LE:
3365 if (e_flags & EF_MIPS_NOREORDER)
3366 strcat (buf, ", noreorder");
3367
3368 if (e_flags & EF_MIPS_PIC)
3369 strcat (buf, ", pic");
3370
3371 if (e_flags & EF_MIPS_CPIC)
3372 strcat (buf, ", cpic");
3373
3374 if (e_flags & EF_MIPS_UCODE)
3375 strcat (buf, ", ugen_reserved");
3376
3377 if (e_flags & EF_MIPS_ABI2)
3378 strcat (buf, ", abi2");
3379
3380 if (e_flags & EF_MIPS_OPTIONS_FIRST)
3381 strcat (buf, ", odk first");
3382
3383 if (e_flags & EF_MIPS_32BITMODE)
3384 strcat (buf, ", 32bitmode");
3385
3386 if (e_flags & EF_MIPS_NAN2008)
3387 strcat (buf, ", nan2008");
3388
3389 if (e_flags & EF_MIPS_FP64)
3390 strcat (buf, ", fp64");
3391
3392 switch ((e_flags & EF_MIPS_MACH))
3393 {
3394 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3395 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3396 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3397 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3398 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3399 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3400 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3401 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3402 case E_MIPS_MACH_5900: strcat (buf, ", 5900"); break;
3403 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
3404 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3405 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3406 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3407 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
3408 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3409 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3410 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3411 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
3412 case E_MIPS_MACH_IAMR2: strcat (buf, ", interaptiv-mr2"); break;
3413 case 0:
3414 /* We simply ignore the field in this case to avoid confusion:
3415 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3416 extension. */
3417 break;
3418 default: strcat (buf, _(", unknown CPU")); break;
3419 }
3420
3421 switch ((e_flags & EF_MIPS_ABI))
3422 {
3423 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3424 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3425 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3426 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3427 case 0:
3428 /* We simply ignore the field in this case to avoid confusion:
3429 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3430 This means it is likely to be an o32 file, but not for
3431 sure. */
3432 break;
3433 default: strcat (buf, _(", unknown ABI")); break;
3434 }
3435
3436 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3437 strcat (buf, ", mdmx");
3438
3439 if (e_flags & EF_MIPS_ARCH_ASE_M16)
3440 strcat (buf, ", mips16");
3441
3442 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3443 strcat (buf, ", micromips");
3444
3445 switch ((e_flags & EF_MIPS_ARCH))
3446 {
3447 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3448 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3449 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3450 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3451 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3452 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3453 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3454 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3455 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3456 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3457 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3458 default: strcat (buf, _(", unknown ISA")); break;
3459 }
3460 break;
3461
3462 case EM_NDS32:
3463 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3464 break;
3465
3466 case EM_NFP:
3467 switch (EF_NFP_MACH (e_flags))
3468 {
3469 case E_NFP_MACH_3200:
3470 strcat (buf, ", NFP-32xx");
3471 break;
3472 case E_NFP_MACH_6000:
3473 strcat (buf, ", NFP-6xxx");
3474 break;
3475 }
3476 break;
3477
3478 case EM_RISCV:
3479 if (e_flags & EF_RISCV_RVC)
3480 strcat (buf, ", RVC");
3481
3482 if (e_flags & EF_RISCV_RVE)
3483 strcat (buf, ", RVE");
3484
3485 switch (e_flags & EF_RISCV_FLOAT_ABI)
3486 {
3487 case EF_RISCV_FLOAT_ABI_SOFT:
3488 strcat (buf, ", soft-float ABI");
3489 break;
3490
3491 case EF_RISCV_FLOAT_ABI_SINGLE:
3492 strcat (buf, ", single-float ABI");
3493 break;
3494
3495 case EF_RISCV_FLOAT_ABI_DOUBLE:
3496 strcat (buf, ", double-float ABI");
3497 break;
3498
3499 case EF_RISCV_FLOAT_ABI_QUAD:
3500 strcat (buf, ", quad-float ABI");
3501 break;
3502 }
3503 break;
3504
3505 case EM_SH:
3506 switch ((e_flags & EF_SH_MACH_MASK))
3507 {
3508 case EF_SH1: strcat (buf, ", sh1"); break;
3509 case EF_SH2: strcat (buf, ", sh2"); break;
3510 case EF_SH3: strcat (buf, ", sh3"); break;
3511 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3512 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3513 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3514 case EF_SH3E: strcat (buf, ", sh3e"); break;
3515 case EF_SH4: strcat (buf, ", sh4"); break;
3516 case EF_SH5: strcat (buf, ", sh5"); break;
3517 case EF_SH2E: strcat (buf, ", sh2e"); break;
3518 case EF_SH4A: strcat (buf, ", sh4a"); break;
3519 case EF_SH2A: strcat (buf, ", sh2a"); break;
3520 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3521 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3522 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3523 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3524 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3525 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3526 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3527 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3528 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3529 default: strcat (buf, _(", unknown ISA")); break;
3530 }
3531
3532 if (e_flags & EF_SH_PIC)
3533 strcat (buf, ", pic");
3534
3535 if (e_flags & EF_SH_FDPIC)
3536 strcat (buf, ", fdpic");
3537 break;
3538
3539 case EM_OR1K:
3540 if (e_flags & EF_OR1K_NODELAY)
3541 strcat (buf, ", no delay");
3542 break;
3543
3544 case EM_SPARCV9:
3545 if (e_flags & EF_SPARC_32PLUS)
3546 strcat (buf, ", v8+");
3547
3548 if (e_flags & EF_SPARC_SUN_US1)
3549 strcat (buf, ", ultrasparcI");
3550
3551 if (e_flags & EF_SPARC_SUN_US3)
3552 strcat (buf, ", ultrasparcIII");
3553
3554 if (e_flags & EF_SPARC_HAL_R1)
3555 strcat (buf, ", halr1");
3556
3557 if (e_flags & EF_SPARC_LEDATA)
3558 strcat (buf, ", ledata");
3559
3560 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3561 strcat (buf, ", tso");
3562
3563 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3564 strcat (buf, ", pso");
3565
3566 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3567 strcat (buf, ", rmo");
3568 break;
3569
3570 case EM_PARISC:
3571 switch (e_flags & EF_PARISC_ARCH)
3572 {
3573 case EFA_PARISC_1_0:
3574 strcpy (buf, ", PA-RISC 1.0");
3575 break;
3576 case EFA_PARISC_1_1:
3577 strcpy (buf, ", PA-RISC 1.1");
3578 break;
3579 case EFA_PARISC_2_0:
3580 strcpy (buf, ", PA-RISC 2.0");
3581 break;
3582 default:
3583 break;
3584 }
3585 if (e_flags & EF_PARISC_TRAPNIL)
3586 strcat (buf, ", trapnil");
3587 if (e_flags & EF_PARISC_EXT)
3588 strcat (buf, ", ext");
3589 if (e_flags & EF_PARISC_LSB)
3590 strcat (buf, ", lsb");
3591 if (e_flags & EF_PARISC_WIDE)
3592 strcat (buf, ", wide");
3593 if (e_flags & EF_PARISC_NO_KABP)
3594 strcat (buf, ", no kabp");
3595 if (e_flags & EF_PARISC_LAZYSWAP)
3596 strcat (buf, ", lazyswap");
3597 break;
3598
3599 case EM_PJ:
3600 case EM_PJ_OLD:
3601 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3602 strcat (buf, ", new calling convention");
3603
3604 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3605 strcat (buf, ", gnu calling convention");
3606 break;
3607
3608 case EM_IA_64:
3609 if ((e_flags & EF_IA_64_ABI64))
3610 strcat (buf, ", 64-bit");
3611 else
3612 strcat (buf, ", 32-bit");
3613 if ((e_flags & EF_IA_64_REDUCEDFP))
3614 strcat (buf, ", reduced fp model");
3615 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3616 strcat (buf, ", no function descriptors, constant gp");
3617 else if ((e_flags & EF_IA_64_CONS_GP))
3618 strcat (buf, ", constant gp");
3619 if ((e_flags & EF_IA_64_ABSOLUTE))
3620 strcat (buf, ", absolute");
3621 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3622 {
3623 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3624 strcat (buf, ", vms_linkages");
3625 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3626 {
3627 case EF_IA_64_VMS_COMCOD_SUCCESS:
3628 break;
3629 case EF_IA_64_VMS_COMCOD_WARNING:
3630 strcat (buf, ", warning");
3631 break;
3632 case EF_IA_64_VMS_COMCOD_ERROR:
3633 strcat (buf, ", error");
3634 break;
3635 case EF_IA_64_VMS_COMCOD_ABORT:
3636 strcat (buf, ", abort");
3637 break;
3638 default:
3639 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3640 e_flags & EF_IA_64_VMS_COMCOD);
3641 strcat (buf, ", <unknown>");
3642 }
3643 }
3644 break;
3645
3646 case EM_VAX:
3647 if ((e_flags & EF_VAX_NONPIC))
3648 strcat (buf, ", non-PIC");
3649 if ((e_flags & EF_VAX_DFLOAT))
3650 strcat (buf, ", D-Float");
3651 if ((e_flags & EF_VAX_GFLOAT))
3652 strcat (buf, ", G-Float");
3653 break;
3654
3655 case EM_VISIUM:
3656 if (e_flags & EF_VISIUM_ARCH_MCM)
3657 strcat (buf, ", mcm");
3658 else if (e_flags & EF_VISIUM_ARCH_MCM24)
3659 strcat (buf, ", mcm24");
3660 if (e_flags & EF_VISIUM_ARCH_GR6)
3661 strcat (buf, ", gr6");
3662 break;
3663
3664 case EM_RL78:
3665 switch (e_flags & E_FLAG_RL78_CPU_MASK)
3666 {
3667 case E_FLAG_RL78_ANY_CPU: break;
3668 case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3669 case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3670 case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3671 }
3672 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3673 strcat (buf, ", 64-bit doubles");
3674 break;
3675
3676 case EM_RX:
3677 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3678 strcat (buf, ", 64-bit doubles");
3679 if (e_flags & E_FLAG_RX_DSP)
3680 strcat (buf, ", dsp");
3681 if (e_flags & E_FLAG_RX_PID)
3682 strcat (buf, ", pid");
3683 if (e_flags & E_FLAG_RX_ABI)
3684 strcat (buf, ", RX ABI");
3685 if (e_flags & E_FLAG_RX_SINSNS_SET)
3686 strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3687 ? ", uses String instructions" : ", bans String instructions");
3688 if (e_flags & E_FLAG_RX_V2)
3689 strcat (buf, ", V2");
3690 break;
3691
3692 case EM_S390:
3693 if (e_flags & EF_S390_HIGH_GPRS)
3694 strcat (buf, ", highgprs");
3695 break;
3696
3697 case EM_TI_C6000:
3698 if ((e_flags & EF_C6000_REL))
3699 strcat (buf, ", relocatable module");
3700 break;
3701
3702 case EM_MSP430:
3703 strcat (buf, _(": architecture variant: "));
3704 switch (e_flags & EF_MSP430_MACH)
3705 {
3706 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3707 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3708 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3709 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3710 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3711 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3712 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3713 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3714 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3715 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3716 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3717 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3718 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3719 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3720 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3721 default:
3722 strcat (buf, _(": unknown")); break;
3723 }
3724
3725 if (e_flags & ~ EF_MSP430_MACH)
3726 strcat (buf, _(": unknown extra flag bits also present"));
3727 }
3728 }
3729
3730 return buf;
3731 }
3732
3733 static const char *
3734 get_osabi_name (Filedata * filedata, unsigned int osabi)
3735 {
3736 static char buff[32];
3737
3738 switch (osabi)
3739 {
3740 case ELFOSABI_NONE: return "UNIX - System V";
3741 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3742 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
3743 case ELFOSABI_GNU: return "UNIX - GNU";
3744 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3745 case ELFOSABI_AIX: return "UNIX - AIX";
3746 case ELFOSABI_IRIX: return "UNIX - IRIX";
3747 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3748 case ELFOSABI_TRU64: return "UNIX - TRU64";
3749 case ELFOSABI_MODESTO: return "Novell - Modesto";
3750 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3751 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3752 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3753 case ELFOSABI_AROS: return "AROS";
3754 case ELFOSABI_FENIXOS: return "FenixOS";
3755 case ELFOSABI_CLOUDABI: return "Nuxi CloudABI";
3756 case ELFOSABI_OPENVOS: return "Stratus Technologies OpenVOS";
3757 default:
3758 if (osabi >= 64)
3759 switch (filedata->file_header.e_machine)
3760 {
3761 case EM_ARM:
3762 switch (osabi)
3763 {
3764 case ELFOSABI_ARM: return "ARM";
3765 case ELFOSABI_ARM_FDPIC: return "ARM FDPIC";
3766 default:
3767 break;
3768 }
3769 break;
3770
3771 case EM_MSP430:
3772 case EM_MSP430_OLD:
3773 case EM_VISIUM:
3774 switch (osabi)
3775 {
3776 case ELFOSABI_STANDALONE: return _("Standalone App");
3777 default:
3778 break;
3779 }
3780 break;
3781
3782 case EM_TI_C6000:
3783 switch (osabi)
3784 {
3785 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3786 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3787 default:
3788 break;
3789 }
3790 break;
3791
3792 default:
3793 break;
3794 }
3795 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3796 return buff;
3797 }
3798 }
3799
3800 static const char *
3801 get_aarch64_segment_type (unsigned long type)
3802 {
3803 switch (type)
3804 {
3805 case PT_AARCH64_ARCHEXT: return "AARCH64_ARCHEXT";
3806 default: return NULL;
3807 }
3808 }
3809
3810 static const char *
3811 get_arm_segment_type (unsigned long type)
3812 {
3813 switch (type)
3814 {
3815 case PT_ARM_EXIDX: return "EXIDX";
3816 default: return NULL;
3817 }
3818 }
3819
3820 static const char *
3821 get_s390_segment_type (unsigned long type)
3822 {
3823 switch (type)
3824 {
3825 case PT_S390_PGSTE: return "S390_PGSTE";
3826 default: return NULL;
3827 }
3828 }
3829
3830 static const char *
3831 get_mips_segment_type (unsigned long type)
3832 {
3833 switch (type)
3834 {
3835 case PT_MIPS_REGINFO: return "REGINFO";
3836 case PT_MIPS_RTPROC: return "RTPROC";
3837 case PT_MIPS_OPTIONS: return "OPTIONS";
3838 case PT_MIPS_ABIFLAGS: return "ABIFLAGS";
3839 default: return NULL;
3840 }
3841 }
3842
3843 static const char *
3844 get_parisc_segment_type (unsigned long type)
3845 {
3846 switch (type)
3847 {
3848 case PT_HP_TLS: return "HP_TLS";
3849 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3850 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3851 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3852 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3853 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3854 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3855 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3856 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3857 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3858 case PT_HP_PARALLEL: return "HP_PARALLEL";
3859 case PT_HP_FASTBIND: return "HP_FASTBIND";
3860 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3861 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3862 case PT_HP_STACK: return "HP_STACK";
3863 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
3864 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3865 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
3866 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
3867 default: return NULL;
3868 }
3869 }
3870
3871 static const char *
3872 get_ia64_segment_type (unsigned long type)
3873 {
3874 switch (type)
3875 {
3876 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3877 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
3878 case PT_HP_TLS: return "HP_TLS";
3879 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3880 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3881 case PT_IA_64_HP_STACK: return "HP_STACK";
3882 default: return NULL;
3883 }
3884 }
3885
3886 static const char *
3887 get_tic6x_segment_type (unsigned long type)
3888 {
3889 switch (type)
3890 {
3891 case PT_C6000_PHATTR: return "C6000_PHATTR";
3892 default: return NULL;
3893 }
3894 }
3895
3896 static const char *
3897 get_solaris_segment_type (unsigned long type)
3898 {
3899 switch (type)
3900 {
3901 case 0x6464e550: return "PT_SUNW_UNWIND";
3902 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3903 case 0x6ffffff7: return "PT_LOSUNW";
3904 case 0x6ffffffa: return "PT_SUNWBSS";
3905 case 0x6ffffffb: return "PT_SUNWSTACK";
3906 case 0x6ffffffc: return "PT_SUNWDTRACE";
3907 case 0x6ffffffd: return "PT_SUNWCAP";
3908 case 0x6fffffff: return "PT_HISUNW";
3909 default: return NULL;
3910 }
3911 }
3912
3913 static const char *
3914 get_segment_type (Filedata * filedata, unsigned long p_type)
3915 {
3916 static char buff[32];
3917
3918 switch (p_type)
3919 {
3920 case PT_NULL: return "NULL";
3921 case PT_LOAD: return "LOAD";
3922 case PT_DYNAMIC: return "DYNAMIC";
3923 case PT_INTERP: return "INTERP";
3924 case PT_NOTE: return "NOTE";
3925 case PT_SHLIB: return "SHLIB";
3926 case PT_PHDR: return "PHDR";
3927 case PT_TLS: return "TLS";
3928 case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
3929 case PT_GNU_STACK: return "GNU_STACK";
3930 case PT_GNU_RELRO: return "GNU_RELRO";
3931
3932 default:
3933 if (p_type >= PT_GNU_MBIND_LO && p_type <= PT_GNU_MBIND_HI)
3934 {
3935 sprintf (buff, "GNU_MBIND+%#lx",
3936 p_type - PT_GNU_MBIND_LO);
3937 }
3938 else if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3939 {
3940 const char * result;
3941
3942 switch (filedata->file_header.e_machine)
3943 {
3944 case EM_AARCH64:
3945 result = get_aarch64_segment_type (p_type);
3946 break;
3947 case EM_ARM:
3948 result = get_arm_segment_type (p_type);
3949 break;
3950 case EM_MIPS:
3951 case EM_MIPS_RS3_LE:
3952 result = get_mips_segment_type (p_type);
3953 break;
3954 case EM_PARISC:
3955 result = get_parisc_segment_type (p_type);
3956 break;
3957 case EM_IA_64:
3958 result = get_ia64_segment_type (p_type);
3959 break;
3960 case EM_TI_C6000:
3961 result = get_tic6x_segment_type (p_type);
3962 break;
3963 case EM_S390:
3964 case EM_S390_OLD:
3965 result = get_s390_segment_type (p_type);
3966 break;
3967 default:
3968 result = NULL;
3969 break;
3970 }
3971
3972 if (result != NULL)
3973 return result;
3974
3975 sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
3976 }
3977 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3978 {
3979 const char * result;
3980
3981 switch (filedata->file_header.e_machine)
3982 {
3983 case EM_PARISC:
3984 result = get_parisc_segment_type (p_type);
3985 break;
3986 case EM_IA_64:
3987 result = get_ia64_segment_type (p_type);
3988 break;
3989 default:
3990 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
3991 result = get_solaris_segment_type (p_type);
3992 else
3993 result = NULL;
3994 break;
3995 }
3996
3997 if (result != NULL)
3998 return result;
3999
4000 sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
4001 }
4002 else
4003 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
4004
4005 return buff;
4006 }
4007 }
4008
4009 static const char *
4010 get_arc_section_type_name (unsigned int sh_type)
4011 {
4012 switch (sh_type)
4013 {
4014 case SHT_ARC_ATTRIBUTES: return "ARC_ATTRIBUTES";
4015 default:
4016 break;
4017 }
4018 return NULL;
4019 }
4020
4021 static const char *
4022 get_mips_section_type_name (unsigned int sh_type)
4023 {
4024 switch (sh_type)
4025 {
4026 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
4027 case SHT_MIPS_MSYM: return "MIPS_MSYM";
4028 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
4029 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
4030 case SHT_MIPS_UCODE: return "MIPS_UCODE";
4031 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
4032 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
4033 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
4034 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
4035 case SHT_MIPS_RELD: return "MIPS_RELD";
4036 case SHT_MIPS_IFACE: return "MIPS_IFACE";
4037 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
4038 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
4039 case SHT_MIPS_SHDR: return "MIPS_SHDR";
4040 case SHT_MIPS_FDESC: return "MIPS_FDESC";
4041 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
4042 case SHT_MIPS_DENSE: return "MIPS_DENSE";
4043 case SHT_MIPS_PDESC: return "MIPS_PDESC";
4044 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
4045 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
4046 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
4047 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
4048 case SHT_MIPS_LINE: return "MIPS_LINE";
4049 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
4050 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
4051 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
4052 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
4053 case SHT_MIPS_DWARF: return "MIPS_DWARF";
4054 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
4055 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
4056 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
4057 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
4058 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
4059 case SHT_MIPS_XLATE: return "MIPS_XLATE";
4060 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
4061 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
4062 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
4063 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
4064 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
4065 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
4066 default:
4067 break;
4068 }
4069 return NULL;
4070 }
4071
4072 static const char *
4073 get_parisc_section_type_name (unsigned int sh_type)
4074 {
4075 switch (sh_type)
4076 {
4077 case SHT_PARISC_EXT: return "PARISC_EXT";
4078 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
4079 case SHT_PARISC_DOC: return "PARISC_DOC";
4080 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
4081 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
4082 case SHT_PARISC_STUBS: return "PARISC_STUBS";
4083 case SHT_PARISC_DLKM: return "PARISC_DLKM";
4084 default: return NULL;
4085 }
4086 }
4087
4088 static const char *
4089 get_ia64_section_type_name (Filedata * filedata, unsigned int sh_type)
4090 {
4091 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4092 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
4093 return get_osabi_name (filedata, (sh_type & 0x00FF0000) >> 16);
4094
4095 switch (sh_type)
4096 {
4097 case SHT_IA_64_EXT: return "IA_64_EXT";
4098 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
4099 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
4100 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
4101 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
4102 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
4103 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
4104 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
4105 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
4106 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
4107 default:
4108 break;
4109 }
4110 return NULL;
4111 }
4112
4113 static const char *
4114 get_x86_64_section_type_name (unsigned int sh_type)
4115 {
4116 switch (sh_type)
4117 {
4118 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
4119 default: return NULL;
4120 }
4121 }
4122
4123 static const char *
4124 get_aarch64_section_type_name (unsigned int sh_type)
4125 {
4126 switch (sh_type)
4127 {
4128 case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
4129 default: return NULL;
4130 }
4131 }
4132
4133 static const char *
4134 get_arm_section_type_name (unsigned int sh_type)
4135 {
4136 switch (sh_type)
4137 {
4138 case SHT_ARM_EXIDX: return "ARM_EXIDX";
4139 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
4140 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
4141 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
4142 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
4143 default: return NULL;
4144 }
4145 }
4146
4147 static const char *
4148 get_tic6x_section_type_name (unsigned int sh_type)
4149 {
4150 switch (sh_type)
4151 {
4152 case SHT_C6000_UNWIND: return "C6000_UNWIND";
4153 case SHT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
4154 case SHT_C6000_ATTRIBUTES: return "C6000_ATTRIBUTES";
4155 case SHT_TI_ICODE: return "TI_ICODE";
4156 case SHT_TI_XREF: return "TI_XREF";
4157 case SHT_TI_HANDLER: return "TI_HANDLER";
4158 case SHT_TI_INITINFO: return "TI_INITINFO";
4159 case SHT_TI_PHATTRS: return "TI_PHATTRS";
4160 default: return NULL;
4161 }
4162 }
4163
4164 static const char *
4165 get_msp430x_section_type_name (unsigned int sh_type)
4166 {
4167 switch (sh_type)
4168 {
4169 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
4170 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
4171 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
4172 default: return NULL;
4173 }
4174 }
4175
4176 static const char *
4177 get_nfp_section_type_name (unsigned int sh_type)
4178 {
4179 switch (sh_type)
4180 {
4181 case SHT_NFP_MECONFIG: return "NFP_MECONFIG";
4182 case SHT_NFP_INITREG: return "NFP_INITREG";
4183 case SHT_NFP_UDEBUG: return "NFP_UDEBUG";
4184 default: return NULL;
4185 }
4186 }
4187
4188 static const char *
4189 get_v850_section_type_name (unsigned int sh_type)
4190 {
4191 switch (sh_type)
4192 {
4193 case SHT_V850_SCOMMON: return "V850 Small Common";
4194 case SHT_V850_TCOMMON: return "V850 Tiny Common";
4195 case SHT_V850_ZCOMMON: return "V850 Zero Common";
4196 case SHT_RENESAS_IOP: return "RENESAS IOP";
4197 case SHT_RENESAS_INFO: return "RENESAS INFO";
4198 default: return NULL;
4199 }
4200 }
4201
4202 static const char *
4203 get_section_type_name (Filedata * filedata, unsigned int sh_type)
4204 {
4205 static char buff[32];
4206 const char * result;
4207
4208 switch (sh_type)
4209 {
4210 case SHT_NULL: return "NULL";
4211 case SHT_PROGBITS: return "PROGBITS";
4212 case SHT_SYMTAB: return "SYMTAB";
4213 case SHT_STRTAB: return "STRTAB";
4214 case SHT_RELA: return "RELA";
4215 case SHT_HASH: return "HASH";
4216 case SHT_DYNAMIC: return "DYNAMIC";
4217 case SHT_NOTE: return "NOTE";
4218 case SHT_NOBITS: return "NOBITS";
4219 case SHT_REL: return "REL";
4220 case SHT_SHLIB: return "SHLIB";
4221 case SHT_DYNSYM: return "DYNSYM";
4222 case SHT_INIT_ARRAY: return "INIT_ARRAY";
4223 case SHT_FINI_ARRAY: return "FINI_ARRAY";
4224 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
4225 case SHT_GNU_HASH: return "GNU_HASH";
4226 case SHT_GROUP: return "GROUP";
4227 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICES";
4228 case SHT_GNU_verdef: return "VERDEF";
4229 case SHT_GNU_verneed: return "VERNEED";
4230 case SHT_GNU_versym: return "VERSYM";
4231 case 0x6ffffff0: return "VERSYM";
4232 case 0x6ffffffc: return "VERDEF";
4233 case 0x7ffffffd: return "AUXILIARY";
4234 case 0x7fffffff: return "FILTER";
4235 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
4236
4237 default:
4238 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4239 {
4240 switch (filedata->file_header.e_machine)
4241 {
4242 case EM_ARC:
4243 case EM_ARC_COMPACT:
4244 case EM_ARC_COMPACT2:
4245 result = get_arc_section_type_name (sh_type);
4246 break;
4247 case EM_MIPS:
4248 case EM_MIPS_RS3_LE:
4249 result = get_mips_section_type_name (sh_type);
4250 break;
4251 case EM_PARISC:
4252 result = get_parisc_section_type_name (sh_type);
4253 break;
4254 case EM_IA_64:
4255 result = get_ia64_section_type_name (filedata, sh_type);
4256 break;
4257 case EM_X86_64:
4258 case EM_L1OM:
4259 case EM_K1OM:
4260 result = get_x86_64_section_type_name (sh_type);
4261 break;
4262 case EM_AARCH64:
4263 result = get_aarch64_section_type_name (sh_type);
4264 break;
4265 case EM_ARM:
4266 result = get_arm_section_type_name (sh_type);
4267 break;
4268 case EM_TI_C6000:
4269 result = get_tic6x_section_type_name (sh_type);
4270 break;
4271 case EM_MSP430:
4272 result = get_msp430x_section_type_name (sh_type);
4273 break;
4274 case EM_NFP:
4275 result = get_nfp_section_type_name (sh_type);
4276 break;
4277 case EM_V800:
4278 case EM_V850:
4279 case EM_CYGNUS_V850:
4280 result = get_v850_section_type_name (sh_type);
4281 break;
4282 default:
4283 result = NULL;
4284 break;
4285 }
4286
4287 if (result != NULL)
4288 return result;
4289
4290 sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
4291 }
4292 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
4293 {
4294 switch (filedata->file_header.e_machine)
4295 {
4296 case EM_IA_64:
4297 result = get_ia64_section_type_name (filedata, sh_type);
4298 break;
4299 default:
4300 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4301 result = get_solaris_section_type (sh_type);
4302 else
4303 {
4304 switch (sh_type)
4305 {
4306 case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
4307 case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
4308 case SHT_GNU_HASH: result = "GNU_HASH"; break;
4309 case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
4310 default:
4311 result = NULL;
4312 break;
4313 }
4314 }
4315 break;
4316 }
4317
4318 if (result != NULL)
4319 return result;
4320
4321 sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
4322 }
4323 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
4324 {
4325 switch (filedata->file_header.e_machine)
4326 {
4327 case EM_V800:
4328 case EM_V850:
4329 case EM_CYGNUS_V850:
4330 result = get_v850_section_type_name (sh_type);
4331 break;
4332 default:
4333 result = NULL;
4334 break;
4335 }
4336
4337 if (result != NULL)
4338 return result;
4339
4340 sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4341 }
4342 else
4343 /* This message is probably going to be displayed in a 15
4344 character wide field, so put the hex value first. */
4345 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
4346
4347 return buff;
4348 }
4349 }
4350
4351 #define OPTION_DEBUG_DUMP 512
4352 #define OPTION_DYN_SYMS 513
4353 #define OPTION_DWARF_DEPTH 514
4354 #define OPTION_DWARF_START 515
4355 #define OPTION_DWARF_CHECK 516
4356
4357 static struct option options[] =
4358 {
4359 {"all", no_argument, 0, 'a'},
4360 {"file-header", no_argument, 0, 'h'},
4361 {"program-headers", no_argument, 0, 'l'},
4362 {"headers", no_argument, 0, 'e'},
4363 {"histogram", no_argument, 0, 'I'},
4364 {"segments", no_argument, 0, 'l'},
4365 {"sections", no_argument, 0, 'S'},
4366 {"section-headers", no_argument, 0, 'S'},
4367 {"section-groups", no_argument, 0, 'g'},
4368 {"section-details", no_argument, 0, 't'},
4369 {"full-section-name",no_argument, 0, 'N'},
4370 {"symbols", no_argument, 0, 's'},
4371 {"syms", no_argument, 0, 's'},
4372 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
4373 {"relocs", no_argument, 0, 'r'},
4374 {"notes", no_argument, 0, 'n'},
4375 {"dynamic", no_argument, 0, 'd'},
4376 {"arch-specific", no_argument, 0, 'A'},
4377 {"version-info", no_argument, 0, 'V'},
4378 {"use-dynamic", no_argument, 0, 'D'},
4379 {"unwind", no_argument, 0, 'u'},
4380 {"archive-index", no_argument, 0, 'c'},
4381 {"hex-dump", required_argument, 0, 'x'},
4382 {"relocated-dump", required_argument, 0, 'R'},
4383 {"string-dump", required_argument, 0, 'p'},
4384 {"decompress", no_argument, 0, 'z'},
4385 #ifdef SUPPORT_DISASSEMBLY
4386 {"instruction-dump", required_argument, 0, 'i'},
4387 #endif
4388 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
4389
4390 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
4391 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4392 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
4393
4394 {"version", no_argument, 0, 'v'},
4395 {"wide", no_argument, 0, 'W'},
4396 {"help", no_argument, 0, 'H'},
4397 {0, no_argument, 0, 0}
4398 };
4399
4400 static void
4401 usage (FILE * stream)
4402 {
4403 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4404 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4405 fprintf (stream, _(" Options are:\n\
4406 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4407 -h --file-header Display the ELF file header\n\
4408 -l --program-headers Display the program headers\n\
4409 --segments An alias for --program-headers\n\
4410 -S --section-headers Display the sections' header\n\
4411 --sections An alias for --section-headers\n\
4412 -g --section-groups Display the section groups\n\
4413 -t --section-details Display the section details\n\
4414 -e --headers Equivalent to: -h -l -S\n\
4415 -s --syms Display the symbol table\n\
4416 --symbols An alias for --syms\n\
4417 --dyn-syms Display the dynamic symbol table\n\
4418 -n --notes Display the core notes (if present)\n\
4419 -r --relocs Display the relocations (if present)\n\
4420 -u --unwind Display the unwind info (if present)\n\
4421 -d --dynamic Display the dynamic section (if present)\n\
4422 -V --version-info Display the version sections (if present)\n\
4423 -A --arch-specific Display architecture specific information (if any)\n\
4424 -c --archive-index Display the symbol/file index in an archive\n\
4425 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4426 -x --hex-dump=<number|name>\n\
4427 Dump the contents of section <number|name> as bytes\n\
4428 -p --string-dump=<number|name>\n\
4429 Dump the contents of section <number|name> as strings\n\
4430 -R --relocated-dump=<number|name>\n\
4431 Dump the contents of section <number|name> as relocated bytes\n\
4432 -z --decompress Decompress section before dumping it\n\
4433 -w[lLiaprmfFsoRtUuTgAckK] or\n\
4434 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4435 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4436 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4437 =addr,=cu_index,=links,=follow-links]\n\
4438 Display the contents of DWARF debug sections\n"));
4439 fprintf (stream, _("\
4440 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4441 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4442 or deeper\n"));
4443 #ifdef SUPPORT_DISASSEMBLY
4444 fprintf (stream, _("\
4445 -i --instruction-dump=<number|name>\n\
4446 Disassemble the contents of section <number|name>\n"));
4447 #endif
4448 fprintf (stream, _("\
4449 -I --histogram Display histogram of bucket list lengths\n\
4450 -W --wide Allow output width to exceed 80 characters\n\
4451 @<file> Read options from <file>\n\
4452 -H --help Display this information\n\
4453 -v --version Display the version number of readelf\n"));
4454
4455 if (REPORT_BUGS_TO[0] && stream == stdout)
4456 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4457
4458 exit (stream == stdout ? 0 : 1);
4459 }
4460
4461 /* Record the fact that the user wants the contents of section number
4462 SECTION to be displayed using the method(s) encoded as flags bits
4463 in TYPE. Note, TYPE can be zero if we are creating the array for
4464 the first time. */
4465
4466 static void
4467 request_dump_bynumber (Filedata * filedata, unsigned int section, dump_type type)
4468 {
4469 if (section >= filedata->num_dump_sects)
4470 {
4471 dump_type * new_dump_sects;
4472
4473 new_dump_sects = (dump_type *) calloc (section + 1,
4474 sizeof (* new_dump_sects));
4475
4476 if (new_dump_sects == NULL)
4477 error (_("Out of memory allocating dump request table.\n"));
4478 else
4479 {
4480 if (filedata->dump_sects)
4481 {
4482 /* Copy current flag settings. */
4483 memcpy (new_dump_sects, filedata->dump_sects,
4484 filedata->num_dump_sects * sizeof (* new_dump_sects));
4485
4486 free (filedata->dump_sects);
4487 }
4488
4489 filedata->dump_sects = new_dump_sects;
4490 filedata->num_dump_sects = section + 1;
4491 }
4492 }
4493
4494 if (filedata->dump_sects)
4495 filedata->dump_sects[section] |= type;
4496 }
4497
4498 /* Request a dump by section name. */
4499
4500 static void
4501 request_dump_byname (const char * section, dump_type type)
4502 {
4503 struct dump_list_entry * new_request;
4504
4505 new_request = (struct dump_list_entry *)
4506 malloc (sizeof (struct dump_list_entry));
4507 if (!new_request)
4508 error (_("Out of memory allocating dump request table.\n"));
4509
4510 new_request->name = strdup (section);
4511 if (!new_request->name)
4512 error (_("Out of memory allocating dump request table.\n"));
4513
4514 new_request->type = type;
4515
4516 new_request->next = dump_sects_byname;
4517 dump_sects_byname = new_request;
4518 }
4519
4520 static inline void
4521 request_dump (Filedata * filedata, dump_type type)
4522 {
4523 int section;
4524 char * cp;
4525
4526 do_dump++;
4527 section = strtoul (optarg, & cp, 0);
4528
4529 if (! *cp && section >= 0)
4530 request_dump_bynumber (filedata, section, type);
4531 else
4532 request_dump_byname (optarg, type);
4533 }
4534
4535 static void
4536 parse_args (Filedata * filedata, int argc, char ** argv)
4537 {
4538 int c;
4539
4540 if (argc < 2)
4541 usage (stderr);
4542
4543 while ((c = getopt_long
4544 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4545 {
4546 switch (c)
4547 {
4548 case 0:
4549 /* Long options. */
4550 break;
4551 case 'H':
4552 usage (stdout);
4553 break;
4554
4555 case 'a':
4556 do_syms = TRUE;
4557 do_reloc = TRUE;
4558 do_unwind = TRUE;
4559 do_dynamic = TRUE;
4560 do_header = TRUE;
4561 do_sections = TRUE;
4562 do_section_groups = TRUE;
4563 do_segments = TRUE;
4564 do_version = TRUE;
4565 do_histogram = TRUE;
4566 do_arch = TRUE;
4567 do_notes = TRUE;
4568 break;
4569 case 'g':
4570 do_section_groups = TRUE;
4571 break;
4572 case 't':
4573 case 'N':
4574 do_sections = TRUE;
4575 do_section_details = TRUE;
4576 break;
4577 case 'e':
4578 do_header = TRUE;
4579 do_sections = TRUE;
4580 do_segments = TRUE;
4581 break;
4582 case 'A':
4583 do_arch = TRUE;
4584 break;
4585 case 'D':
4586 do_using_dynamic = TRUE;
4587 break;
4588 case 'r':
4589 do_reloc = TRUE;
4590 break;
4591 case 'u':
4592 do_unwind = TRUE;
4593 break;
4594 case 'h':
4595 do_header = TRUE;
4596 break;
4597 case 'l':
4598 do_segments = TRUE;
4599 break;
4600 case 's':
4601 do_syms = TRUE;
4602 break;
4603 case 'S':
4604 do_sections = TRUE;
4605 break;
4606 case 'd':
4607 do_dynamic = TRUE;
4608 break;
4609 case 'I':
4610 do_histogram = TRUE;
4611 break;
4612 case 'n':
4613 do_notes = TRUE;
4614 break;
4615 case 'c':
4616 do_archive_index = TRUE;
4617 break;
4618 case 'x':
4619 request_dump (filedata, HEX_DUMP);
4620 break;
4621 case 'p':
4622 request_dump (filedata, STRING_DUMP);
4623 break;
4624 case 'R':
4625 request_dump (filedata, RELOC_DUMP);
4626 break;
4627 case 'z':
4628 decompress_dumps = TRUE;
4629 break;
4630 case 'w':
4631 do_dump = TRUE;
4632 if (optarg == 0)
4633 {
4634 do_debugging = TRUE;
4635 dwarf_select_sections_all ();
4636 }
4637 else
4638 {
4639 do_debugging = FALSE;
4640 dwarf_select_sections_by_letters (optarg);
4641 }
4642 break;
4643 case OPTION_DEBUG_DUMP:
4644 do_dump = TRUE;
4645 if (optarg == 0)
4646 do_debugging = TRUE;
4647 else
4648 {
4649 do_debugging = FALSE;
4650 dwarf_select_sections_by_names (optarg);
4651 }
4652 break;
4653 case OPTION_DWARF_DEPTH:
4654 {
4655 char *cp;
4656
4657 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4658 }
4659 break;
4660 case OPTION_DWARF_START:
4661 {
4662 char *cp;
4663
4664 dwarf_start_die = strtoul (optarg, & cp, 0);
4665 }
4666 break;
4667 case OPTION_DWARF_CHECK:
4668 dwarf_check = TRUE;
4669 break;
4670 case OPTION_DYN_SYMS:
4671 do_dyn_syms = TRUE;
4672 break;
4673 #ifdef SUPPORT_DISASSEMBLY
4674 case 'i':
4675 request_dump (filedata, DISASS_DUMP);
4676 break;
4677 #endif
4678 case 'v':
4679 print_version (program_name);
4680 break;
4681 case 'V':
4682 do_version = TRUE;
4683 break;
4684 case 'W':
4685 do_wide = TRUE;
4686 break;
4687 default:
4688 /* xgettext:c-format */
4689 error (_("Invalid option '-%c'\n"), c);
4690 /* Fall through. */
4691 case '?':
4692 usage (stderr);
4693 }
4694 }
4695
4696 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4697 && !do_segments && !do_header && !do_dump && !do_version
4698 && !do_histogram && !do_debugging && !do_arch && !do_notes
4699 && !do_section_groups && !do_archive_index
4700 && !do_dyn_syms)
4701 usage (stderr);
4702 }
4703
4704 static const char *
4705 get_elf_class (unsigned int elf_class)
4706 {
4707 static char buff[32];
4708
4709 switch (elf_class)
4710 {
4711 case ELFCLASSNONE: return _("none");
4712 case ELFCLASS32: return "ELF32";
4713 case ELFCLASS64: return "ELF64";
4714 default:
4715 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4716 return buff;
4717 }
4718 }
4719
4720 static const char *
4721 get_data_encoding (unsigned int encoding)
4722 {
4723 static char buff[32];
4724
4725 switch (encoding)
4726 {
4727 case ELFDATANONE: return _("none");
4728 case ELFDATA2LSB: return _("2's complement, little endian");
4729 case ELFDATA2MSB: return _("2's complement, big endian");
4730 default:
4731 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4732 return buff;
4733 }
4734 }
4735
4736 /* Decode the data held in 'filedata->file_header'. */
4737
4738 static bfd_boolean
4739 process_file_header (Filedata * filedata)
4740 {
4741 Elf_Internal_Ehdr * header = & filedata->file_header;
4742
4743 if ( header->e_ident[EI_MAG0] != ELFMAG0
4744 || header->e_ident[EI_MAG1] != ELFMAG1
4745 || header->e_ident[EI_MAG2] != ELFMAG2
4746 || header->e_ident[EI_MAG3] != ELFMAG3)
4747 {
4748 error
4749 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4750 return FALSE;
4751 }
4752
4753 init_dwarf_regnames (header->e_machine);
4754
4755 if (do_header)
4756 {
4757 unsigned i;
4758
4759 printf (_("ELF Header:\n"));
4760 printf (_(" Magic: "));
4761 for (i = 0; i < EI_NIDENT; i++)
4762 printf ("%2.2x ", header->e_ident[i]);
4763 printf ("\n");
4764 printf (_(" Class: %s\n"),
4765 get_elf_class (header->e_ident[EI_CLASS]));
4766 printf (_(" Data: %s\n"),
4767 get_data_encoding (header->e_ident[EI_DATA]));
4768 printf (_(" Version: %d%s\n"),
4769 header->e_ident[EI_VERSION],
4770 (header->e_ident[EI_VERSION] == EV_CURRENT
4771 ? _(" (current)")
4772 : (header->e_ident[EI_VERSION] != EV_NONE
4773 ? _(" <unknown>")
4774 : "")));
4775 printf (_(" OS/ABI: %s\n"),
4776 get_osabi_name (filedata, header->e_ident[EI_OSABI]));
4777 printf (_(" ABI Version: %d\n"),
4778 header->e_ident[EI_ABIVERSION]);
4779 printf (_(" Type: %s\n"),
4780 get_file_type (header->e_type));
4781 printf (_(" Machine: %s\n"),
4782 get_machine_name (header->e_machine));
4783 printf (_(" Version: 0x%lx\n"),
4784 header->e_version);
4785
4786 printf (_(" Entry point address: "));
4787 print_vma (header->e_entry, PREFIX_HEX);
4788 printf (_("\n Start of program headers: "));
4789 print_vma (header->e_phoff, DEC);
4790 printf (_(" (bytes into file)\n Start of section headers: "));
4791 print_vma (header->e_shoff, DEC);
4792 printf (_(" (bytes into file)\n"));
4793
4794 printf (_(" Flags: 0x%lx%s\n"),
4795 header->e_flags,
4796 get_machine_flags (filedata, header->e_flags, header->e_machine));
4797 printf (_(" Size of this header: %u (bytes)\n"),
4798 header->e_ehsize);
4799 printf (_(" Size of program headers: %u (bytes)\n"),
4800 header->e_phentsize);
4801 printf (_(" Number of program headers: %u"),
4802 header->e_phnum);
4803 if (filedata->section_headers != NULL
4804 && header->e_phnum == PN_XNUM
4805 && filedata->section_headers[0].sh_info != 0)
4806 {
4807 header->e_phnum = filedata->section_headers[0].sh_info;
4808 printf (" (%u)", header->e_phnum);
4809 }
4810 putc ('\n', stdout);
4811 printf (_(" Size of section headers: %u (bytes)\n"),
4812 header->e_shentsize);
4813 printf (_(" Number of section headers: %u"),
4814 header->e_shnum);
4815 if (filedata->section_headers != NULL && header->e_shnum == SHN_UNDEF)
4816 {
4817 header->e_shnum = filedata->section_headers[0].sh_size;
4818 printf (" (%u)", header->e_shnum);
4819 }
4820 putc ('\n', stdout);
4821 printf (_(" Section header string table index: %u"),
4822 header->e_shstrndx);
4823 if (filedata->section_headers != NULL
4824 && header->e_shstrndx == (SHN_XINDEX & 0xffff))
4825 {
4826 header->e_shstrndx = filedata->section_headers[0].sh_link;
4827 printf (" (%u)", header->e_shstrndx);
4828 }
4829 if (header->e_shstrndx != SHN_UNDEF
4830 && header->e_shstrndx >= header->e_shnum)
4831 {
4832 header->e_shstrndx = SHN_UNDEF;
4833 printf (_(" <corrupt: out of range>"));
4834 }
4835 putc ('\n', stdout);
4836 }
4837
4838 if (filedata->section_headers != NULL)
4839 {
4840 if (header->e_phnum == PN_XNUM
4841 && filedata->section_headers[0].sh_info != 0)
4842 header->e_phnum = filedata->section_headers[0].sh_info;
4843 if (header->e_shnum == SHN_UNDEF)
4844 header->e_shnum = filedata->section_headers[0].sh_size;
4845 if (header->e_shstrndx == (SHN_XINDEX & 0xffff))
4846 header->e_shstrndx = filedata->section_headers[0].sh_link;
4847 if (header->e_shstrndx >= header->e_shnum)
4848 header->e_shstrndx = SHN_UNDEF;
4849 free (filedata->section_headers);
4850 filedata->section_headers = NULL;
4851 }
4852
4853 return TRUE;
4854 }
4855
4856 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4857 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
4858
4859 static bfd_boolean
4860 get_32bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4861 {
4862 Elf32_External_Phdr * phdrs;
4863 Elf32_External_Phdr * external;
4864 Elf_Internal_Phdr * internal;
4865 unsigned int i;
4866 unsigned int size = filedata->file_header.e_phentsize;
4867 unsigned int num = filedata->file_header.e_phnum;
4868
4869 /* PR binutils/17531: Cope with unexpected section header sizes. */
4870 if (size == 0 || num == 0)
4871 return FALSE;
4872 if (size < sizeof * phdrs)
4873 {
4874 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4875 return FALSE;
4876 }
4877 if (size > sizeof * phdrs)
4878 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4879
4880 phdrs = (Elf32_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4881 size, num, _("program headers"));
4882 if (phdrs == NULL)
4883 return FALSE;
4884
4885 for (i = 0, internal = pheaders, external = phdrs;
4886 i < filedata->file_header.e_phnum;
4887 i++, internal++, external++)
4888 {
4889 internal->p_type = BYTE_GET (external->p_type);
4890 internal->p_offset = BYTE_GET (external->p_offset);
4891 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4892 internal->p_paddr = BYTE_GET (external->p_paddr);
4893 internal->p_filesz = BYTE_GET (external->p_filesz);
4894 internal->p_memsz = BYTE_GET (external->p_memsz);
4895 internal->p_flags = BYTE_GET (external->p_flags);
4896 internal->p_align = BYTE_GET (external->p_align);
4897 }
4898
4899 free (phdrs);
4900 return TRUE;
4901 }
4902
4903 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4904 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
4905
4906 static bfd_boolean
4907 get_64bit_program_headers (Filedata * filedata, Elf_Internal_Phdr * pheaders)
4908 {
4909 Elf64_External_Phdr * phdrs;
4910 Elf64_External_Phdr * external;
4911 Elf_Internal_Phdr * internal;
4912 unsigned int i;
4913 unsigned int size = filedata->file_header.e_phentsize;
4914 unsigned int num = filedata->file_header.e_phnum;
4915
4916 /* PR binutils/17531: Cope with unexpected section header sizes. */
4917 if (size == 0 || num == 0)
4918 return FALSE;
4919 if (size < sizeof * phdrs)
4920 {
4921 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4922 return FALSE;
4923 }
4924 if (size > sizeof * phdrs)
4925 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4926
4927 phdrs = (Elf64_External_Phdr *) get_data (NULL, filedata, filedata->file_header.e_phoff,
4928 size, num, _("program headers"));
4929 if (!phdrs)
4930 return FALSE;
4931
4932 for (i = 0, internal = pheaders, external = phdrs;
4933 i < filedata->file_header.e_phnum;
4934 i++, internal++, external++)
4935 {
4936 internal->p_type = BYTE_GET (external->p_type);
4937 internal->p_flags = BYTE_GET (external->p_flags);
4938 internal->p_offset = BYTE_GET (external->p_offset);
4939 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4940 internal->p_paddr = BYTE_GET (external->p_paddr);
4941 internal->p_filesz = BYTE_GET (external->p_filesz);
4942 internal->p_memsz = BYTE_GET (external->p_memsz);
4943 internal->p_align = BYTE_GET (external->p_align);
4944 }
4945
4946 free (phdrs);
4947 return TRUE;
4948 }
4949
4950 /* Returns TRUE if the program headers were read into `program_headers'. */
4951
4952 static bfd_boolean
4953 get_program_headers (Filedata * filedata)
4954 {
4955 Elf_Internal_Phdr * phdrs;
4956
4957 /* Check cache of prior read. */
4958 if (filedata->program_headers != NULL)
4959 return TRUE;
4960
4961 /* Be kind to memory checkers by looking for
4962 e_phnum values which we know must be invalid. */
4963 if (filedata->file_header.e_phnum
4964 * (is_32bit_elf ? sizeof (Elf32_External_Phdr) : sizeof (Elf64_External_Phdr))
4965 >= filedata->file_size)
4966 {
4967 error (_("Too many program headers - %#x - the file is not that big\n"),
4968 filedata->file_header.e_phnum);
4969 return FALSE;
4970 }
4971
4972 phdrs = (Elf_Internal_Phdr *) cmalloc (filedata->file_header.e_phnum,
4973 sizeof (Elf_Internal_Phdr));
4974 if (phdrs == NULL)
4975 {
4976 error (_("Out of memory reading %u program headers\n"),
4977 filedata->file_header.e_phnum);
4978 return FALSE;
4979 }
4980
4981 if (is_32bit_elf
4982 ? get_32bit_program_headers (filedata, phdrs)
4983 : get_64bit_program_headers (filedata, phdrs))
4984 {
4985 filedata->program_headers = phdrs;
4986 return TRUE;
4987 }
4988
4989 free (phdrs);
4990 return FALSE;
4991 }
4992
4993 /* Returns TRUE if the program headers were loaded. */
4994
4995 static bfd_boolean
4996 process_program_headers (Filedata * filedata)
4997 {
4998 Elf_Internal_Phdr * segment;
4999 unsigned int i;
5000 Elf_Internal_Phdr * previous_load = NULL;
5001
5002 if (filedata->file_header.e_phnum == 0)
5003 {
5004 /* PR binutils/12467. */
5005 if (filedata->file_header.e_phoff != 0)
5006 {
5007 warn (_("possibly corrupt ELF header - it has a non-zero program"
5008 " header offset, but no program headers\n"));
5009 return FALSE;
5010 }
5011 else if (do_segments)
5012 printf (_("\nThere are no program headers in this file.\n"));
5013 return TRUE;
5014 }
5015
5016 if (do_segments && !do_header)
5017 {
5018 printf (_("\nElf file type is %s\n"), get_file_type (filedata->file_header.e_type));
5019 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata->file_header.e_entry));
5020 printf (ngettext ("There is %d program header, starting at offset %s\n",
5021 "There are %d program headers, starting at offset %s\n",
5022 filedata->file_header.e_phnum),
5023 filedata->file_header.e_phnum,
5024 bfd_vmatoa ("u", filedata->file_header.e_phoff));
5025 }
5026
5027 if (! get_program_headers (filedata))
5028 return TRUE;
5029
5030 if (do_segments)
5031 {
5032 if (filedata->file_header.e_phnum > 1)
5033 printf (_("\nProgram Headers:\n"));
5034 else
5035 printf (_("\nProgram Headers:\n"));
5036
5037 if (is_32bit_elf)
5038 printf
5039 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5040 else if (do_wide)
5041 printf
5042 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5043 else
5044 {
5045 printf
5046 (_(" Type Offset VirtAddr PhysAddr\n"));
5047 printf
5048 (_(" FileSiz MemSiz Flags Align\n"));
5049 }
5050 }
5051
5052 dynamic_addr = 0;
5053 dynamic_size = 0;
5054
5055 for (i = 0, segment = filedata->program_headers;
5056 i < filedata->file_header.e_phnum;
5057 i++, segment++)
5058 {
5059 if (do_segments)
5060 {
5061 printf (" %-14.14s ", get_segment_type (filedata, segment->p_type));
5062
5063 if (is_32bit_elf)
5064 {
5065 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5066 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
5067 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
5068 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
5069 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
5070 printf ("%c%c%c ",
5071 (segment->p_flags & PF_R ? 'R' : ' '),
5072 (segment->p_flags & PF_W ? 'W' : ' '),
5073 (segment->p_flags & PF_X ? 'E' : ' '));
5074 printf ("%#lx", (unsigned long) segment->p_align);
5075 }
5076 else if (do_wide)
5077 {
5078 if ((unsigned long) segment->p_offset == segment->p_offset)
5079 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
5080 else
5081 {
5082 print_vma (segment->p_offset, FULL_HEX);
5083 putchar (' ');
5084 }
5085
5086 print_vma (segment->p_vaddr, FULL_HEX);
5087 putchar (' ');
5088 print_vma (segment->p_paddr, FULL_HEX);
5089 putchar (' ');
5090
5091 if ((unsigned long) segment->p_filesz == segment->p_filesz)
5092 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
5093 else
5094 {
5095 print_vma (segment->p_filesz, FULL_HEX);
5096 putchar (' ');
5097 }
5098
5099 if ((unsigned long) segment->p_memsz == segment->p_memsz)
5100 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
5101 else
5102 {
5103 print_vma (segment->p_memsz, FULL_HEX);
5104 }
5105
5106 printf (" %c%c%c ",
5107 (segment->p_flags & PF_R ? 'R' : ' '),
5108 (segment->p_flags & PF_W ? 'W' : ' '),
5109 (segment->p_flags & PF_X ? 'E' : ' '));
5110
5111 if ((unsigned long) segment->p_align == segment->p_align)
5112 printf ("%#lx", (unsigned long) segment->p_align);
5113 else
5114 {
5115 print_vma (segment->p_align, PREFIX_HEX);
5116 }
5117 }
5118 else
5119 {
5120 print_vma (segment->p_offset, FULL_HEX);
5121 putchar (' ');
5122 print_vma (segment->p_vaddr, FULL_HEX);
5123 putchar (' ');
5124 print_vma (segment->p_paddr, FULL_HEX);
5125 printf ("\n ");
5126 print_vma (segment->p_filesz, FULL_HEX);
5127 putchar (' ');
5128 print_vma (segment->p_memsz, FULL_HEX);
5129 printf (" %c%c%c ",
5130 (segment->p_flags & PF_R ? 'R' : ' '),
5131 (segment->p_flags & PF_W ? 'W' : ' '),
5132 (segment->p_flags & PF_X ? 'E' : ' '));
5133 print_vma (segment->p_align, PREFIX_HEX);
5134 }
5135
5136 putc ('\n', stdout);
5137 }
5138
5139 switch (segment->p_type)
5140 {
5141 case PT_LOAD:
5142 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5143 required by the ELF standard, several programs, including the Linux
5144 kernel, make use of non-ordered segments. */
5145 if (previous_load
5146 && previous_load->p_vaddr > segment->p_vaddr)
5147 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5148 #endif
5149 if (segment->p_memsz < segment->p_filesz)
5150 error (_("the segment's file size is larger than its memory size\n"));
5151 previous_load = segment;
5152 break;
5153
5154 case PT_PHDR:
5155 /* PR 20815 - Verify that the program header is loaded into memory. */
5156 if (i > 0 && previous_load != NULL)
5157 error (_("the PHDR segment must occur before any LOAD segment\n"));
5158 if (filedata->file_header.e_machine != EM_PARISC)
5159 {
5160 unsigned int j;
5161
5162 for (j = 1; j < filedata->file_header.e_phnum; j++)
5163 if (filedata->program_headers[j].p_vaddr <= segment->p_vaddr
5164 && (filedata->program_headers[j].p_vaddr
5165 + filedata->program_headers[j].p_memsz)
5166 >= (segment->p_vaddr + segment->p_filesz))
5167 break;
5168 if (j == filedata->file_header.e_phnum)
5169 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5170 }
5171 break;
5172
5173 case PT_DYNAMIC:
5174 if (dynamic_addr)
5175 error (_("more than one dynamic segment\n"));
5176
5177 /* By default, assume that the .dynamic section is the first
5178 section in the DYNAMIC segment. */
5179 dynamic_addr = segment->p_offset;
5180 dynamic_size = segment->p_filesz;
5181
5182 /* Try to locate the .dynamic section. If there is
5183 a section header table, we can easily locate it. */
5184 if (filedata->section_headers != NULL)
5185 {
5186 Elf_Internal_Shdr * sec;
5187
5188 sec = find_section (filedata, ".dynamic");
5189 if (sec == NULL || sec->sh_size == 0)
5190 {
5191 /* A corresponding .dynamic section is expected, but on
5192 IA-64/OpenVMS it is OK for it to be missing. */
5193 if (!is_ia64_vms (filedata))
5194 error (_("no .dynamic section in the dynamic segment\n"));
5195 break;
5196 }
5197
5198 if (sec->sh_type == SHT_NOBITS)
5199 {
5200 dynamic_size = 0;
5201 break;
5202 }
5203
5204 dynamic_addr = sec->sh_offset;
5205 dynamic_size = sec->sh_size;
5206
5207 if (dynamic_addr < segment->p_offset
5208 || dynamic_addr > segment->p_offset + segment->p_filesz)
5209 warn (_("the .dynamic section is not contained"
5210 " within the dynamic segment\n"));
5211 else if (dynamic_addr > segment->p_offset)
5212 warn (_("the .dynamic section is not the first section"
5213 " in the dynamic segment.\n"));
5214 }
5215
5216 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5217 segment. Check this after matching against the section headers
5218 so we don't warn on debuginfo file (which have NOBITS .dynamic
5219 sections). */
5220 if (dynamic_addr + dynamic_size >= filedata->file_size)
5221 {
5222 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5223 dynamic_addr = dynamic_size = 0;
5224 }
5225 break;
5226
5227 case PT_INTERP:
5228 if (fseek (filedata->handle, archive_file_offset + (long) segment->p_offset,
5229 SEEK_SET))
5230 error (_("Unable to find program interpreter name\n"));
5231 else
5232 {
5233 char fmt [32];
5234 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
5235
5236 if (ret >= (int) sizeof (fmt) || ret < 0)
5237 error (_("Internal error: failed to create format string to display program interpreter\n"));
5238
5239 program_interpreter[0] = 0;
5240 if (fscanf (filedata->handle, fmt, program_interpreter) <= 0)
5241 error (_("Unable to read program interpreter name\n"));
5242
5243 if (do_segments)
5244 printf (_(" [Requesting program interpreter: %s]\n"),
5245 program_interpreter);
5246 }
5247 break;
5248 }
5249 }
5250
5251 if (do_segments
5252 && filedata->section_headers != NULL
5253 && filedata->string_table != NULL)
5254 {
5255 printf (_("\n Section to Segment mapping:\n"));
5256 printf (_(" Segment Sections...\n"));
5257
5258 for (i = 0; i < filedata->file_header.e_phnum; i++)
5259 {
5260 unsigned int j;
5261 Elf_Internal_Shdr * section;
5262
5263 segment = filedata->program_headers + i;
5264 section = filedata->section_headers + 1;
5265
5266 printf (" %2.2d ", i);
5267
5268 for (j = 1; j < filedata->file_header.e_shnum; j++, section++)
5269 {
5270 if (!ELF_TBSS_SPECIAL (section, segment)
5271 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
5272 printf ("%s ", printable_section_name (filedata, section));
5273 }
5274
5275 putc ('\n',stdout);
5276 }
5277 }
5278
5279 return TRUE;
5280 }
5281
5282
5283 /* Find the file offset corresponding to VMA by using the program headers. */
5284
5285 static long
5286 offset_from_vma (Filedata * filedata, bfd_vma vma, bfd_size_type size)
5287 {
5288 Elf_Internal_Phdr * seg;
5289
5290 if (! get_program_headers (filedata))
5291 {
5292 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5293 return (long) vma;
5294 }
5295
5296 for (seg = filedata->program_headers;
5297 seg < filedata->program_headers + filedata->file_header.e_phnum;
5298 ++seg)
5299 {
5300 if (seg->p_type != PT_LOAD)
5301 continue;
5302
5303 if (vma >= (seg->p_vaddr & -seg->p_align)
5304 && vma + size <= seg->p_vaddr + seg->p_filesz)
5305 return vma - seg->p_vaddr + seg->p_offset;
5306 }
5307
5308 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5309 (unsigned long) vma);
5310 return (long) vma;
5311 }
5312
5313
5314 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5315 If PROBE is true, this is just a probe and we do not generate any error
5316 messages if the load fails. */
5317
5318 static bfd_boolean
5319 get_32bit_section_headers (Filedata * filedata, bfd_boolean probe)
5320 {
5321 Elf32_External_Shdr * shdrs;
5322 Elf_Internal_Shdr * internal;
5323 unsigned int i;
5324 unsigned int size = filedata->file_header.e_shentsize;
5325 unsigned int num = probe ? 1 : filedata->file_header.e_shnum;
5326
5327 /* PR binutils/17531: Cope with unexpected section header sizes. */
5328 if (size == 0 || num == 0)
5329 return FALSE;
5330 if (size < sizeof * shdrs)
5331 {
5332 if (! probe)
5333 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5334 return FALSE;
5335 }
5336 if (!probe && size > sizeof * shdrs)
5337 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5338
5339 shdrs = (Elf32_External_Shdr *) get_data (NULL, filedata, filedata->file_header.e_shoff,
5340 size, num,
5341 probe ? NULL : _("section headers"));
5342 if (shdrs == NULL)
5343 return FALSE;
5344
5345 free (filedata->section_headers);
5346 filedata->section_headers = (Elf_Internal_Shdr *)
5347 cmalloc (num, sizeof (Elf_Internal_Shdr));
5348 if (filedata->section_headers == NULL)
5349 {
5350 if (!probe)
5351 error (_("Out of memory reading %u section headers\n"), num);
5352 free (shdrs);
5353 return FALSE;
5354 }
5355
5356 for (i = 0, internal = filedata->section_headers;
5357 i < num;
5358 i++, internal++)
5359 {
5360 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5361 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
5362 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5363 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5364 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5365 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5366 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5367 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5368 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5369 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
5370 if (!probe && internal->sh_link > num)
5371 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5372 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5373 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5374 }
5375
5376 free (shdrs);
5377 return TRUE;
5378 }
5379
5380 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5381
5382 static bfd_boolean
5383 get_64bit_section_headers (Filedata * filedata, bfd_boolean probe)
5384 {
5385 Elf64_External_Shdr * shdrs;
5386 Elf_Internal_Shdr * internal;
5387 unsigned int i;
5388 unsigned int size = filedata->file_header.e_shentsize;
5389 unsigned int num = probe ? 1 : filedata->file_header.e_shnum;
5390
5391 /* PR binutils/17531: Cope with unexpected section header sizes. */
5392 if (size == 0 || num == 0)
5393 return FALSE;
5394
5395 if (size < sizeof * shdrs)
5396 {
5397 if (! probe)
5398 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5399 return FALSE;
5400 }
5401
5402 if (! probe && size > sizeof * shdrs)
5403 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5404
5405 shdrs = (Elf64_External_Shdr *) get_data (NULL, filedata,
5406 filedata->file_header.e_shoff,
5407 size, num,
5408 probe ? NULL : _("section headers"));
5409 if (shdrs == NULL)
5410 return FALSE;
5411
5412 free (filedata->section_headers);
5413 filedata->section_headers = (Elf_Internal_Shdr *)
5414 cmalloc (num, sizeof (Elf_Internal_Shdr));
5415 if (filedata->section_headers == NULL)
5416 {
5417 if (! probe)
5418 error (_("Out of memory reading %u section headers\n"), num);
5419 free (shdrs);
5420 return FALSE;
5421 }
5422
5423 for (i = 0, internal = filedata->section_headers;
5424 i < num;
5425 i++, internal++)
5426 {
5427 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5428 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
5429 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5430 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5431 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5432 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
5433 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5434 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5435 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5436 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5437 if (!probe && internal->sh_link > num)
5438 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5439 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5440 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5441 }
5442
5443 free (shdrs);
5444 return TRUE;
5445 }
5446
5447 static Elf_Internal_Sym *
5448 get_32bit_elf_symbols (Filedata * filedata,
5449 Elf_Internal_Shdr * section,
5450 unsigned long * num_syms_return)
5451 {
5452 unsigned long number = 0;
5453 Elf32_External_Sym * esyms = NULL;
5454 Elf_External_Sym_Shndx * shndx = NULL;
5455 Elf_Internal_Sym * isyms = NULL;
5456 Elf_Internal_Sym * psym;
5457 unsigned int j;
5458 elf_section_list * entry;
5459
5460 if (section->sh_size == 0)
5461 {
5462 if (num_syms_return != NULL)
5463 * num_syms_return = 0;
5464 return NULL;
5465 }
5466
5467 /* Run some sanity checks first. */
5468 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5469 {
5470 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5471 printable_section_name (filedata, section),
5472 (unsigned long) section->sh_entsize);
5473 goto exit_point;
5474 }
5475
5476 if (section->sh_size > filedata->file_size)
5477 {
5478 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5479 printable_section_name (filedata, section),
5480 (unsigned long) section->sh_size);
5481 goto exit_point;
5482 }
5483
5484 number = section->sh_size / section->sh_entsize;
5485
5486 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5487 {
5488 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5489 (unsigned long) section->sh_size,
5490 printable_section_name (filedata, section),
5491 (unsigned long) section->sh_entsize);
5492 goto exit_point;
5493 }
5494
5495 esyms = (Elf32_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5496 section->sh_size, _("symbols"));
5497 if (esyms == NULL)
5498 goto exit_point;
5499
5500 shndx = NULL;
5501 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5502 {
5503 if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5504 continue;
5505
5506 if (shndx != NULL)
5507 {
5508 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5509 free (shndx);
5510 }
5511
5512 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5513 entry->hdr->sh_offset,
5514 1, entry->hdr->sh_size,
5515 _("symbol table section indices"));
5516 if (shndx == NULL)
5517 goto exit_point;
5518
5519 /* PR17531: file: heap-buffer-overflow */
5520 if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5521 {
5522 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5523 printable_section_name (filedata, entry->hdr),
5524 (unsigned long) entry->hdr->sh_size,
5525 (unsigned long) section->sh_size);
5526 goto exit_point;
5527 }
5528 }
5529
5530 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5531
5532 if (isyms == NULL)
5533 {
5534 error (_("Out of memory reading %lu symbols\n"),
5535 (unsigned long) number);
5536 goto exit_point;
5537 }
5538
5539 for (j = 0, psym = isyms; j < number; j++, psym++)
5540 {
5541 psym->st_name = BYTE_GET (esyms[j].st_name);
5542 psym->st_value = BYTE_GET (esyms[j].st_value);
5543 psym->st_size = BYTE_GET (esyms[j].st_size);
5544 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5545 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5546 psym->st_shndx
5547 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5548 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5549 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5550 psym->st_info = BYTE_GET (esyms[j].st_info);
5551 psym->st_other = BYTE_GET (esyms[j].st_other);
5552 }
5553
5554 exit_point:
5555 free (shndx);
5556 free (esyms);
5557
5558 if (num_syms_return != NULL)
5559 * num_syms_return = isyms == NULL ? 0 : number;
5560
5561 return isyms;
5562 }
5563
5564 static Elf_Internal_Sym *
5565 get_64bit_elf_symbols (Filedata * filedata,
5566 Elf_Internal_Shdr * section,
5567 unsigned long * num_syms_return)
5568 {
5569 unsigned long number = 0;
5570 Elf64_External_Sym * esyms = NULL;
5571 Elf_External_Sym_Shndx * shndx = NULL;
5572 Elf_Internal_Sym * isyms = NULL;
5573 Elf_Internal_Sym * psym;
5574 unsigned int j;
5575 elf_section_list * entry;
5576
5577 if (section->sh_size == 0)
5578 {
5579 if (num_syms_return != NULL)
5580 * num_syms_return = 0;
5581 return NULL;
5582 }
5583
5584 /* Run some sanity checks first. */
5585 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5586 {
5587 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5588 printable_section_name (filedata, section),
5589 (unsigned long) section->sh_entsize);
5590 goto exit_point;
5591 }
5592
5593 if (section->sh_size > filedata->file_size)
5594 {
5595 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5596 printable_section_name (filedata, section),
5597 (unsigned long) section->sh_size);
5598 goto exit_point;
5599 }
5600
5601 number = section->sh_size / section->sh_entsize;
5602
5603 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5604 {
5605 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5606 (unsigned long) section->sh_size,
5607 printable_section_name (filedata, section),
5608 (unsigned long) section->sh_entsize);
5609 goto exit_point;
5610 }
5611
5612 esyms = (Elf64_External_Sym *) get_data (NULL, filedata, section->sh_offset, 1,
5613 section->sh_size, _("symbols"));
5614 if (!esyms)
5615 goto exit_point;
5616
5617 shndx = NULL;
5618 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5619 {
5620 if (entry->hdr->sh_link != (unsigned long) (section - filedata->section_headers))
5621 continue;
5622
5623 if (shndx != NULL)
5624 {
5625 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5626 free (shndx);
5627 }
5628
5629 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, filedata,
5630 entry->hdr->sh_offset,
5631 1, entry->hdr->sh_size,
5632 _("symbol table section indices"));
5633 if (shndx == NULL)
5634 goto exit_point;
5635
5636 /* PR17531: file: heap-buffer-overflow */
5637 if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5638 {
5639 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5640 printable_section_name (filedata, entry->hdr),
5641 (unsigned long) entry->hdr->sh_size,
5642 (unsigned long) section->sh_size);
5643 goto exit_point;
5644 }
5645 }
5646
5647 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5648
5649 if (isyms == NULL)
5650 {
5651 error (_("Out of memory reading %lu symbols\n"),
5652 (unsigned long) number);
5653 goto exit_point;
5654 }
5655
5656 for (j = 0, psym = isyms; j < number; j++, psym++)
5657 {
5658 psym->st_name = BYTE_GET (esyms[j].st_name);
5659 psym->st_info = BYTE_GET (esyms[j].st_info);
5660 psym->st_other = BYTE_GET (esyms[j].st_other);
5661 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5662
5663 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5664 psym->st_shndx
5665 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5666 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5667 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5668
5669 psym->st_value = BYTE_GET (esyms[j].st_value);
5670 psym->st_size = BYTE_GET (esyms[j].st_size);
5671 }
5672
5673 exit_point:
5674 free (shndx);
5675 free (esyms);
5676
5677 if (num_syms_return != NULL)
5678 * num_syms_return = isyms == NULL ? 0 : number;
5679
5680 return isyms;
5681 }
5682
5683 static const char *
5684 get_elf_section_flags (Filedata * filedata, bfd_vma sh_flags)
5685 {
5686 static char buff[1024];
5687 char * p = buff;
5688 unsigned int field_size = is_32bit_elf ? 8 : 16;
5689 signed int sindex;
5690 unsigned int size = sizeof (buff) - (field_size + 4 + 1);
5691 bfd_vma os_flags = 0;
5692 bfd_vma proc_flags = 0;
5693 bfd_vma unknown_flags = 0;
5694 static const struct
5695 {
5696 const char * str;
5697 unsigned int len;
5698 }
5699 flags [] =
5700 {
5701 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5702 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5703 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5704 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5705 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5706 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5707 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5708 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5709 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5710 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5711 /* IA-64 specific. */
5712 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5713 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5714 /* IA-64 OpenVMS specific. */
5715 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5716 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5717 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5718 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5719 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5720 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5721 /* Generic. */
5722 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5723 /* SPARC specific. */
5724 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5725 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5726 /* ARM specific. */
5727 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5728 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5729 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5730 /* GNU specific. */
5731 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5732 /* VLE specific. */
5733 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5734 };
5735
5736 if (do_section_details)
5737 {
5738 sprintf (buff, "[%*.*lx]: ",
5739 field_size, field_size, (unsigned long) sh_flags);
5740 p += field_size + 4;
5741 }
5742
5743 while (sh_flags)
5744 {
5745 bfd_vma flag;
5746
5747 flag = sh_flags & - sh_flags;
5748 sh_flags &= ~ flag;
5749
5750 if (do_section_details)
5751 {
5752 switch (flag)
5753 {
5754 case SHF_WRITE: sindex = 0; break;
5755 case SHF_ALLOC: sindex = 1; break;
5756 case SHF_EXECINSTR: sindex = 2; break;
5757 case SHF_MERGE: sindex = 3; break;
5758 case SHF_STRINGS: sindex = 4; break;
5759 case SHF_INFO_LINK: sindex = 5; break;
5760 case SHF_LINK_ORDER: sindex = 6; break;
5761 case SHF_OS_NONCONFORMING: sindex = 7; break;
5762 case SHF_GROUP: sindex = 8; break;
5763 case SHF_TLS: sindex = 9; break;
5764 case SHF_EXCLUDE: sindex = 18; break;
5765 case SHF_COMPRESSED: sindex = 20; break;
5766 case SHF_GNU_MBIND: sindex = 24; break;
5767
5768 default:
5769 sindex = -1;
5770 switch (filedata->file_header.e_machine)
5771 {
5772 case EM_IA_64:
5773 if (flag == SHF_IA_64_SHORT)
5774 sindex = 10;
5775 else if (flag == SHF_IA_64_NORECOV)
5776 sindex = 11;
5777 #ifdef BFD64
5778 else if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5779 switch (flag)
5780 {
5781 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5782 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5783 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5784 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5785 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5786 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
5787 default: break;
5788 }
5789 #endif
5790 break;
5791
5792 case EM_386:
5793 case EM_IAMCU:
5794 case EM_X86_64:
5795 case EM_L1OM:
5796 case EM_K1OM:
5797 case EM_OLD_SPARCV9:
5798 case EM_SPARC32PLUS:
5799 case EM_SPARCV9:
5800 case EM_SPARC:
5801 if (flag == SHF_ORDERED)
5802 sindex = 19;
5803 break;
5804
5805 case EM_ARM:
5806 switch (flag)
5807 {
5808 case SHF_ENTRYSECT: sindex = 21; break;
5809 case SHF_ARM_PURECODE: sindex = 22; break;
5810 case SHF_COMDEF: sindex = 23; break;
5811 default: break;
5812 }
5813 break;
5814 case EM_PPC:
5815 if (flag == SHF_PPC_VLE)
5816 sindex = 25;
5817 break;
5818
5819 default:
5820 break;
5821 }
5822 }
5823
5824 if (sindex != -1)
5825 {
5826 if (p != buff + field_size + 4)
5827 {
5828 if (size < (10 + 2))
5829 {
5830 warn (_("Internal error: not enough buffer room for section flag info"));
5831 return _("<unknown>");
5832 }
5833 size -= 2;
5834 *p++ = ',';
5835 *p++ = ' ';
5836 }
5837
5838 size -= flags [sindex].len;
5839 p = stpcpy (p, flags [sindex].str);
5840 }
5841 else if (flag & SHF_MASKOS)
5842 os_flags |= flag;
5843 else if (flag & SHF_MASKPROC)
5844 proc_flags |= flag;
5845 else
5846 unknown_flags |= flag;
5847 }
5848 else
5849 {
5850 switch (flag)
5851 {
5852 case SHF_WRITE: *p = 'W'; break;
5853 case SHF_ALLOC: *p = 'A'; break;
5854 case SHF_EXECINSTR: *p = 'X'; break;
5855 case SHF_MERGE: *p = 'M'; break;
5856 case SHF_STRINGS: *p = 'S'; break;
5857 case SHF_INFO_LINK: *p = 'I'; break;
5858 case SHF_LINK_ORDER: *p = 'L'; break;
5859 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5860 case SHF_GROUP: *p = 'G'; break;
5861 case SHF_TLS: *p = 'T'; break;
5862 case SHF_EXCLUDE: *p = 'E'; break;
5863 case SHF_COMPRESSED: *p = 'C'; break;
5864 case SHF_GNU_MBIND: *p = 'D'; break;
5865
5866 default:
5867 if ((filedata->file_header.e_machine == EM_X86_64
5868 || filedata->file_header.e_machine == EM_L1OM
5869 || filedata->file_header.e_machine == EM_K1OM)
5870 && flag == SHF_X86_64_LARGE)
5871 *p = 'l';
5872 else if (filedata->file_header.e_machine == EM_ARM
5873 && flag == SHF_ARM_PURECODE)
5874 *p = 'y';
5875 else if (filedata->file_header.e_machine == EM_PPC
5876 && flag == SHF_PPC_VLE)
5877 *p = 'v';
5878 else if (flag & SHF_MASKOS)
5879 {
5880 *p = 'o';
5881 sh_flags &= ~ SHF_MASKOS;
5882 }
5883 else if (flag & SHF_MASKPROC)
5884 {
5885 *p = 'p';
5886 sh_flags &= ~ SHF_MASKPROC;
5887 }
5888 else
5889 *p = 'x';
5890 break;
5891 }
5892 p++;
5893 }
5894 }
5895
5896 if (do_section_details)
5897 {
5898 if (os_flags)
5899 {
5900 size -= 5 + field_size;
5901 if (p != buff + field_size + 4)
5902 {
5903 if (size < (2 + 1))
5904 {
5905 warn (_("Internal error: not enough buffer room for section flag info"));
5906 return _("<unknown>");
5907 }
5908 size -= 2;
5909 *p++ = ',';
5910 *p++ = ' ';
5911 }
5912 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5913 (unsigned long) os_flags);
5914 p += 5 + field_size;
5915 }
5916 if (proc_flags)
5917 {
5918 size -= 7 + field_size;
5919 if (p != buff + field_size + 4)
5920 {
5921 if (size < (2 + 1))
5922 {
5923 warn (_("Internal error: not enough buffer room for section flag info"));
5924 return _("<unknown>");
5925 }
5926 size -= 2;
5927 *p++ = ',';
5928 *p++ = ' ';
5929 }
5930 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5931 (unsigned long) proc_flags);
5932 p += 7 + field_size;
5933 }
5934 if (unknown_flags)
5935 {
5936 size -= 10 + field_size;
5937 if (p != buff + field_size + 4)
5938 {
5939 if (size < (2 + 1))
5940 {
5941 warn (_("Internal error: not enough buffer room for section flag info"));
5942 return _("<unknown>");
5943 }
5944 size -= 2;
5945 *p++ = ',';
5946 *p++ = ' ';
5947 }
5948 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5949 (unsigned long) unknown_flags);
5950 p += 10 + field_size;
5951 }
5952 }
5953
5954 *p = '\0';
5955 return buff;
5956 }
5957
5958 static unsigned int
5959 get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
5960 {
5961 if (is_32bit_elf)
5962 {
5963 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5964
5965 if (size < sizeof (* echdr))
5966 {
5967 error (_("Compressed section is too small even for a compression header\n"));
5968 return 0;
5969 }
5970
5971 chdr->ch_type = BYTE_GET (echdr->ch_type);
5972 chdr->ch_size = BYTE_GET (echdr->ch_size);
5973 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5974 return sizeof (*echdr);
5975 }
5976 else
5977 {
5978 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5979
5980 if (size < sizeof (* echdr))
5981 {
5982 error (_("Compressed section is too small even for a compression header\n"));
5983 return 0;
5984 }
5985
5986 chdr->ch_type = BYTE_GET (echdr->ch_type);
5987 chdr->ch_size = BYTE_GET (echdr->ch_size);
5988 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5989 return sizeof (*echdr);
5990 }
5991 }
5992
5993 static bfd_boolean
5994 process_section_headers (Filedata * filedata)
5995 {
5996 Elf_Internal_Shdr * section;
5997 unsigned int i;
5998
5999 filedata->section_headers = NULL;
6000
6001 if (filedata->file_header.e_shnum == 0)
6002 {
6003 /* PR binutils/12467. */
6004 if (filedata->file_header.e_shoff != 0)
6005 {
6006 warn (_("possibly corrupt ELF file header - it has a non-zero"
6007 " section header offset, but no section headers\n"));
6008 return FALSE;
6009 }
6010 else if (do_sections)
6011 printf (_("\nThere are no sections in this file.\n"));
6012
6013 return TRUE;
6014 }
6015
6016 if (do_sections && !do_header)
6017 printf (ngettext ("There is %d section header, "
6018 "starting at offset 0x%lx:\n",
6019 "There are %d section headers, "
6020 "starting at offset 0x%lx:\n",
6021 filedata->file_header.e_shnum),
6022 filedata->file_header.e_shnum,
6023 (unsigned long) filedata->file_header.e_shoff);
6024
6025 if (is_32bit_elf)
6026 {
6027 if (! get_32bit_section_headers (filedata, FALSE))
6028 return FALSE;
6029 }
6030 else
6031 {
6032 if (! get_64bit_section_headers (filedata, FALSE))
6033 return FALSE;
6034 }
6035
6036 /* Read in the string table, so that we have names to display. */
6037 if (filedata->file_header.e_shstrndx != SHN_UNDEF
6038 && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
6039 {
6040 section = filedata->section_headers + filedata->file_header.e_shstrndx;
6041
6042 if (section->sh_size != 0)
6043 {
6044 filedata->string_table = (char *) get_data (NULL, filedata, section->sh_offset,
6045 1, section->sh_size,
6046 _("string table"));
6047
6048 filedata->string_table_length = filedata->string_table != NULL ? section->sh_size : 0;
6049 }
6050 }
6051
6052 /* Scan the sections for the dynamic symbol table
6053 and dynamic string table and debug sections. */
6054 dynamic_symbols = NULL;
6055 dynamic_strings = NULL;
6056 dynamic_syminfo = NULL;
6057 symtab_shndx_list = NULL;
6058
6059 eh_addr_size = is_32bit_elf ? 4 : 8;
6060 switch (filedata->file_header.e_machine)
6061 {
6062 case EM_MIPS:
6063 case EM_MIPS_RS3_LE:
6064 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6065 FDE addresses. However, the ABI also has a semi-official ILP32
6066 variant for which the normal FDE address size rules apply.
6067
6068 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6069 section, where XX is the size of longs in bits. Unfortunately,
6070 earlier compilers provided no way of distinguishing ILP32 objects
6071 from LP64 objects, so if there's any doubt, we should assume that
6072 the official LP64 form is being used. */
6073 if ((filedata->file_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
6074 && find_section (filedata, ".gcc_compiled_long32") == NULL)
6075 eh_addr_size = 8;
6076 break;
6077
6078 case EM_H8_300:
6079 case EM_H8_300H:
6080 switch (filedata->file_header.e_flags & EF_H8_MACH)
6081 {
6082 case E_H8_MACH_H8300:
6083 case E_H8_MACH_H8300HN:
6084 case E_H8_MACH_H8300SN:
6085 case E_H8_MACH_H8300SXN:
6086 eh_addr_size = 2;
6087 break;
6088 case E_H8_MACH_H8300H:
6089 case E_H8_MACH_H8300S:
6090 case E_H8_MACH_H8300SX:
6091 eh_addr_size = 4;
6092 break;
6093 }
6094 break;
6095
6096 case EM_M32C_OLD:
6097 case EM_M32C:
6098 switch (filedata->file_header.e_flags & EF_M32C_CPU_MASK)
6099 {
6100 case EF_M32C_CPU_M16C:
6101 eh_addr_size = 2;
6102 break;
6103 }
6104 break;
6105 }
6106
6107 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6108 do \
6109 { \
6110 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6111 if (section->sh_entsize != expected_entsize) \
6112 { \
6113 char buf[40]; \
6114 sprintf_vma (buf, section->sh_entsize); \
6115 /* Note: coded this way so that there is a single string for \
6116 translation. */ \
6117 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6118 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6119 (unsigned) expected_entsize); \
6120 section->sh_entsize = expected_entsize; \
6121 } \
6122 } \
6123 while (0)
6124
6125 #define CHECK_ENTSIZE(section, i, type) \
6126 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6127 sizeof (Elf64_External_##type))
6128
6129 for (i = 0, section = filedata->section_headers;
6130 i < filedata->file_header.e_shnum;
6131 i++, section++)
6132 {
6133 char * name = SECTION_NAME (section);
6134
6135 if (section->sh_type == SHT_DYNSYM)
6136 {
6137 if (dynamic_symbols != NULL)
6138 {
6139 error (_("File contains multiple dynamic symbol tables\n"));
6140 continue;
6141 }
6142
6143 CHECK_ENTSIZE (section, i, Sym);
6144 dynamic_symbols = GET_ELF_SYMBOLS (filedata, section, & num_dynamic_syms);
6145 }
6146 else if (section->sh_type == SHT_STRTAB
6147 && streq (name, ".dynstr"))
6148 {
6149 if (dynamic_strings != NULL)
6150 {
6151 error (_("File contains multiple dynamic string tables\n"));
6152 continue;
6153 }
6154
6155 dynamic_strings = (char *) get_data (NULL, filedata, section->sh_offset,
6156 1, section->sh_size,
6157 _("dynamic strings"));
6158 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
6159 }
6160 else if (section->sh_type == SHT_SYMTAB_SHNDX)
6161 {
6162 elf_section_list * entry = xmalloc (sizeof * entry);
6163
6164 entry->hdr = section;
6165 entry->next = symtab_shndx_list;
6166 symtab_shndx_list = entry;
6167 }
6168 else if (section->sh_type == SHT_SYMTAB)
6169 CHECK_ENTSIZE (section, i, Sym);
6170 else if (section->sh_type == SHT_GROUP)
6171 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
6172 else if (section->sh_type == SHT_REL)
6173 CHECK_ENTSIZE (section, i, Rel);
6174 else if (section->sh_type == SHT_RELA)
6175 CHECK_ENTSIZE (section, i, Rela);
6176 else if ((do_debugging || do_debug_info || do_debug_abbrevs
6177 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
6178 || do_debug_aranges || do_debug_frames || do_debug_macinfo
6179 || do_debug_str || do_debug_loc || do_debug_ranges
6180 || do_debug_addr || do_debug_cu_index || do_debug_links)
6181 && (const_strneq (name, ".debug_")
6182 || const_strneq (name, ".zdebug_")))
6183 {
6184 if (name[1] == 'z')
6185 name += sizeof (".zdebug_") - 1;
6186 else
6187 name += sizeof (".debug_") - 1;
6188
6189 if (do_debugging
6190 || (do_debug_info && const_strneq (name, "info"))
6191 || (do_debug_info && const_strneq (name, "types"))
6192 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
6193 || (do_debug_lines && strcmp (name, "line") == 0)
6194 || (do_debug_lines && const_strneq (name, "line."))
6195 || (do_debug_pubnames && const_strneq (name, "pubnames"))
6196 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
6197 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
6198 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
6199 || (do_debug_aranges && const_strneq (name, "aranges"))
6200 || (do_debug_ranges && const_strneq (name, "ranges"))
6201 || (do_debug_ranges && const_strneq (name, "rnglists"))
6202 || (do_debug_frames && const_strneq (name, "frame"))
6203 || (do_debug_macinfo && const_strneq (name, "macinfo"))
6204 || (do_debug_macinfo && const_strneq (name, "macro"))
6205 || (do_debug_str && const_strneq (name, "str"))
6206 || (do_debug_loc && const_strneq (name, "loc"))
6207 || (do_debug_loc && const_strneq (name, "loclists"))
6208 || (do_debug_addr && const_strneq (name, "addr"))
6209 || (do_debug_cu_index && const_strneq (name, "cu_index"))
6210 || (do_debug_cu_index && const_strneq (name, "tu_index"))
6211 )
6212 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6213 }
6214 /* Linkonce section to be combined with .debug_info at link time. */
6215 else if ((do_debugging || do_debug_info)
6216 && const_strneq (name, ".gnu.linkonce.wi."))
6217 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6218 else if (do_debug_frames && streq (name, ".eh_frame"))
6219 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6220 else if (do_gdb_index && (streq (name, ".gdb_index")
6221 || streq (name, ".debug_names")))
6222 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6223 /* Trace sections for Itanium VMS. */
6224 else if ((do_debugging || do_trace_info || do_trace_abbrevs
6225 || do_trace_aranges)
6226 && const_strneq (name, ".trace_"))
6227 {
6228 name += sizeof (".trace_") - 1;
6229
6230 if (do_debugging
6231 || (do_trace_info && streq (name, "info"))
6232 || (do_trace_abbrevs && streq (name, "abbrev"))
6233 || (do_trace_aranges && streq (name, "aranges"))
6234 )
6235 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6236 }
6237 else if ((do_debugging || do_debug_links)
6238 && (const_strneq (name, ".gnu_debuglink")
6239 || const_strneq (name, ".gnu_debugaltlink")))
6240 request_dump_bynumber (filedata, i, DEBUG_DUMP);
6241 }
6242
6243 if (! do_sections)
6244 return TRUE;
6245
6246 if (filedata->file_header.e_shnum > 1)
6247 printf (_("\nSection Headers:\n"));
6248 else
6249 printf (_("\nSection Header:\n"));
6250
6251 if (is_32bit_elf)
6252 {
6253 if (do_section_details)
6254 {
6255 printf (_(" [Nr] Name\n"));
6256 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6257 }
6258 else
6259 printf
6260 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6261 }
6262 else if (do_wide)
6263 {
6264 if (do_section_details)
6265 {
6266 printf (_(" [Nr] Name\n"));
6267 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6268 }
6269 else
6270 printf
6271 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6272 }
6273 else
6274 {
6275 if (do_section_details)
6276 {
6277 printf (_(" [Nr] Name\n"));
6278 printf (_(" Type Address Offset Link\n"));
6279 printf (_(" Size EntSize Info Align\n"));
6280 }
6281 else
6282 {
6283 printf (_(" [Nr] Name Type Address Offset\n"));
6284 printf (_(" Size EntSize Flags Link Info Align\n"));
6285 }
6286 }
6287
6288 if (do_section_details)
6289 printf (_(" Flags\n"));
6290
6291 for (i = 0, section = filedata->section_headers;
6292 i < filedata->file_header.e_shnum;
6293 i++, section++)
6294 {
6295 /* Run some sanity checks on the section header. */
6296
6297 /* Check the sh_link field. */
6298 switch (section->sh_type)
6299 {
6300 case SHT_SYMTAB_SHNDX:
6301 case SHT_GROUP:
6302 case SHT_HASH:
6303 case SHT_GNU_HASH:
6304 case SHT_GNU_versym:
6305 case SHT_REL:
6306 case SHT_RELA:
6307 if (section->sh_link < 1
6308 || section->sh_link >= filedata->file_header.e_shnum
6309 || (filedata->section_headers[section->sh_link].sh_type != SHT_SYMTAB
6310 && filedata->section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6311 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6312 i, section->sh_link);
6313 break;
6314
6315 case SHT_DYNAMIC:
6316 case SHT_SYMTAB:
6317 case SHT_DYNSYM:
6318 case SHT_GNU_verneed:
6319 case SHT_GNU_verdef:
6320 case SHT_GNU_LIBLIST:
6321 if (section->sh_link < 1
6322 || section->sh_link >= filedata->file_header.e_shnum
6323 || filedata->section_headers[section->sh_link].sh_type != SHT_STRTAB)
6324 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6325 i, section->sh_link);
6326 break;
6327
6328 case SHT_INIT_ARRAY:
6329 case SHT_FINI_ARRAY:
6330 case SHT_PREINIT_ARRAY:
6331 if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6332 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6333 i, section->sh_link);
6334 break;
6335
6336 default:
6337 /* FIXME: Add support for target specific section types. */
6338 #if 0 /* Currently we do not check other section types as there are too
6339 many special cases. Stab sections for example have a type
6340 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6341 section. */
6342 if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6343 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6344 i, section->sh_link);
6345 #endif
6346 break;
6347 }
6348
6349 /* Check the sh_info field. */
6350 switch (section->sh_type)
6351 {
6352 case SHT_REL:
6353 case SHT_RELA:
6354 if (section->sh_info < 1
6355 || section->sh_info >= filedata->file_header.e_shnum
6356 || (filedata->section_headers[section->sh_info].sh_type != SHT_PROGBITS
6357 && filedata->section_headers[section->sh_info].sh_type != SHT_NOBITS
6358 && filedata->section_headers[section->sh_info].sh_type != SHT_NOTE
6359 && filedata->section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6360 /* FIXME: Are other section types valid ? */
6361 && filedata->section_headers[section->sh_info].sh_type < SHT_LOOS))
6362 {
6363 if (section->sh_info == 0
6364 && (filedata->file_header.e_type == ET_EXEC
6365 || filedata->file_header.e_type == ET_DYN
6366 /* These next two tests may be redundant, but
6367 they have been left in for paranoia's sake. */
6368 || streq (SECTION_NAME (section), ".rel.dyn")
6369 || streq (SECTION_NAME (section), ".rela.dyn")))
6370 /* Dynamic relocations apply to segments, not sections, so
6371 they do not need an sh_info value. */
6372 ;
6373 else
6374 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6375 i, section->sh_info);
6376 }
6377 break;
6378
6379 case SHT_DYNAMIC:
6380 case SHT_HASH:
6381 case SHT_SYMTAB_SHNDX:
6382 case SHT_INIT_ARRAY:
6383 case SHT_FINI_ARRAY:
6384 case SHT_PREINIT_ARRAY:
6385 if (section->sh_info != 0)
6386 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6387 i, section->sh_info);
6388 break;
6389
6390 case SHT_GROUP:
6391 case SHT_SYMTAB:
6392 case SHT_DYNSYM:
6393 /* A symbol index - we assume that it is valid. */
6394 break;
6395
6396 default:
6397 /* FIXME: Add support for target specific section types. */
6398 if (section->sh_type == SHT_NOBITS)
6399 /* NOBITS section headers with non-zero sh_info fields can be
6400 created when a binary is stripped of everything but its debug
6401 information. The stripped sections have their headers
6402 preserved but their types set to SHT_NOBITS. So do not check
6403 this type of section. */
6404 ;
6405 else if (section->sh_flags & SHF_INFO_LINK)
6406 {
6407 if (section->sh_info < 1 || section->sh_info >= filedata->file_header.e_shnum)
6408 warn (_("[%2u]: Expected link to another section in info field"), i);
6409 }
6410 else if (section->sh_type < SHT_LOOS
6411 && (section->sh_flags & SHF_GNU_MBIND) == 0
6412 && section->sh_info != 0)
6413 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6414 i, section->sh_info);
6415 break;
6416 }
6417
6418 /* Check the sh_size field. */
6419 if (section->sh_size > filedata->file_size
6420 && section->sh_type != SHT_NOBITS
6421 && section->sh_type != SHT_NULL
6422 && section->sh_type < SHT_LOOS)
6423 warn (_("Size of section %u is larger than the entire file!\n"), i);
6424
6425 printf (" [%2u] ", i);
6426 if (do_section_details)
6427 printf ("%s\n ", printable_section_name (filedata, section));
6428 else
6429 print_symbol (-17, SECTION_NAME (section));
6430
6431 printf (do_wide ? " %-15s " : " %-15.15s ",
6432 get_section_type_name (filedata, section->sh_type));
6433
6434 if (is_32bit_elf)
6435 {
6436 const char * link_too_big = NULL;
6437
6438 print_vma (section->sh_addr, LONG_HEX);
6439
6440 printf ( " %6.6lx %6.6lx %2.2lx",
6441 (unsigned long) section->sh_offset,
6442 (unsigned long) section->sh_size,
6443 (unsigned long) section->sh_entsize);
6444
6445 if (do_section_details)
6446 fputs (" ", stdout);
6447 else
6448 printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6449
6450 if (section->sh_link >= filedata->file_header.e_shnum)
6451 {
6452 link_too_big = "";
6453 /* The sh_link value is out of range. Normally this indicates
6454 an error but it can have special values in Solaris binaries. */
6455 switch (filedata->file_header.e_machine)
6456 {
6457 case EM_386:
6458 case EM_IAMCU:
6459 case EM_X86_64:
6460 case EM_L1OM:
6461 case EM_K1OM:
6462 case EM_OLD_SPARCV9:
6463 case EM_SPARC32PLUS:
6464 case EM_SPARCV9:
6465 case EM_SPARC:
6466 if (section->sh_link == (SHN_BEFORE & 0xffff))
6467 link_too_big = "BEFORE";
6468 else if (section->sh_link == (SHN_AFTER & 0xffff))
6469 link_too_big = "AFTER";
6470 break;
6471 default:
6472 break;
6473 }
6474 }
6475
6476 if (do_section_details)
6477 {
6478 if (link_too_big != NULL && * link_too_big)
6479 printf ("<%s> ", link_too_big);
6480 else
6481 printf ("%2u ", section->sh_link);
6482 printf ("%3u %2lu\n", section->sh_info,
6483 (unsigned long) section->sh_addralign);
6484 }
6485 else
6486 printf ("%2u %3u %2lu\n",
6487 section->sh_link,
6488 section->sh_info,
6489 (unsigned long) section->sh_addralign);
6490
6491 if (link_too_big && ! * link_too_big)
6492 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6493 i, section->sh_link);
6494 }
6495 else if (do_wide)
6496 {
6497 print_vma (section->sh_addr, LONG_HEX);
6498
6499 if ((long) section->sh_offset == section->sh_offset)
6500 printf (" %6.6lx", (unsigned long) section->sh_offset);
6501 else
6502 {
6503 putchar (' ');
6504 print_vma (section->sh_offset, LONG_HEX);
6505 }
6506
6507 if ((unsigned long) section->sh_size == section->sh_size)
6508 printf (" %6.6lx", (unsigned long) section->sh_size);
6509 else
6510 {
6511 putchar (' ');
6512 print_vma (section->sh_size, LONG_HEX);
6513 }
6514
6515 if ((unsigned long) section->sh_entsize == section->sh_entsize)
6516 printf (" %2.2lx", (unsigned long) section->sh_entsize);
6517 else
6518 {
6519 putchar (' ');
6520 print_vma (section->sh_entsize, LONG_HEX);
6521 }
6522
6523 if (do_section_details)
6524 fputs (" ", stdout);
6525 else
6526 printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6527
6528 printf ("%2u %3u ", section->sh_link, section->sh_info);
6529
6530 if ((unsigned long) section->sh_addralign == section->sh_addralign)
6531 printf ("%2lu\n", (unsigned long) section->sh_addralign);
6532 else
6533 {
6534 print_vma (section->sh_addralign, DEC);
6535 putchar ('\n');
6536 }
6537 }
6538 else if (do_section_details)
6539 {
6540 putchar (' ');
6541 print_vma (section->sh_addr, LONG_HEX);
6542 if ((long) section->sh_offset == section->sh_offset)
6543 printf (" %16.16lx", (unsigned long) section->sh_offset);
6544 else
6545 {
6546 printf (" ");
6547 print_vma (section->sh_offset, LONG_HEX);
6548 }
6549 printf (" %u\n ", section->sh_link);
6550 print_vma (section->sh_size, LONG_HEX);
6551 putchar (' ');
6552 print_vma (section->sh_entsize, LONG_HEX);
6553
6554 printf (" %-16u %lu\n",
6555 section->sh_info,
6556 (unsigned long) section->sh_addralign);
6557 }
6558 else
6559 {
6560 putchar (' ');
6561 print_vma (section->sh_addr, LONG_HEX);
6562 if ((long) section->sh_offset == section->sh_offset)
6563 printf (" %8.8lx", (unsigned long) section->sh_offset);
6564 else
6565 {
6566 printf (" ");
6567 print_vma (section->sh_offset, LONG_HEX);
6568 }
6569 printf ("\n ");
6570 print_vma (section->sh_size, LONG_HEX);
6571 printf (" ");
6572 print_vma (section->sh_entsize, LONG_HEX);
6573
6574 printf (" %3s ", get_elf_section_flags (filedata, section->sh_flags));
6575
6576 printf (" %2u %3u %lu\n",
6577 section->sh_link,
6578 section->sh_info,
6579 (unsigned long) section->sh_addralign);
6580 }
6581
6582 if (do_section_details)
6583 {
6584 printf (" %s\n", get_elf_section_flags (filedata, section->sh_flags));
6585 if ((section->sh_flags & SHF_COMPRESSED) != 0)
6586 {
6587 /* Minimum section size is 12 bytes for 32-bit compression
6588 header + 12 bytes for compressed data header. */
6589 unsigned char buf[24];
6590
6591 assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6592 if (get_data (&buf, filedata, section->sh_offset, 1,
6593 sizeof (buf), _("compression header")))
6594 {
6595 Elf_Internal_Chdr chdr;
6596
6597 (void) get_compression_header (&chdr, buf, sizeof (buf));
6598
6599 if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6600 printf (" ZLIB, ");
6601 else
6602 printf (_(" [<unknown>: 0x%x], "),
6603 chdr.ch_type);
6604 print_vma (chdr.ch_size, LONG_HEX);
6605 printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6606 }
6607 }
6608 }
6609 }
6610
6611 if (!do_section_details)
6612 {
6613 /* The ordering of the letters shown here matches the ordering of the
6614 corresponding SHF_xxx values, and hence the order in which these
6615 letters will be displayed to the user. */
6616 printf (_("Key to Flags:\n\
6617 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6618 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6619 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6620 if (filedata->file_header.e_machine == EM_X86_64
6621 || filedata->file_header.e_machine == EM_L1OM
6622 || filedata->file_header.e_machine == EM_K1OM)
6623 printf (_("l (large), "));
6624 else if (filedata->file_header.e_machine == EM_ARM)
6625 printf (_("y (purecode), "));
6626 else if (filedata->file_header.e_machine == EM_PPC)
6627 printf (_("v (VLE), "));
6628 printf ("p (processor specific)\n");
6629 }
6630
6631 return TRUE;
6632 }
6633
6634 static const char *
6635 get_group_flags (unsigned int flags)
6636 {
6637 static char buff[128];
6638
6639 if (flags == 0)
6640 return "";
6641 else if (flags == GRP_COMDAT)
6642 return "COMDAT ";
6643
6644 snprintf (buff, 14, _("[0x%x: "), flags);
6645
6646 flags &= ~ GRP_COMDAT;
6647 if (flags & GRP_MASKOS)
6648 {
6649 strcat (buff, "<OS specific>");
6650 flags &= ~ GRP_MASKOS;
6651 }
6652
6653 if (flags & GRP_MASKPROC)
6654 {
6655 strcat (buff, "<PROC specific>");
6656 flags &= ~ GRP_MASKPROC;
6657 }
6658
6659 if (flags)
6660 strcat (buff, "<unknown>");
6661
6662 strcat (buff, "]");
6663 return buff;
6664 }
6665
6666 static bfd_boolean
6667 process_section_groups (Filedata * filedata)
6668 {
6669 Elf_Internal_Shdr * section;
6670 unsigned int i;
6671 struct group * group;
6672 Elf_Internal_Shdr * symtab_sec;
6673 Elf_Internal_Shdr * strtab_sec;
6674 Elf_Internal_Sym * symtab;
6675 unsigned long num_syms;
6676 char * strtab;
6677 size_t strtab_size;
6678
6679 /* Don't process section groups unless needed. */
6680 if (!do_unwind && !do_section_groups)
6681 return TRUE;
6682
6683 if (filedata->file_header.e_shnum == 0)
6684 {
6685 if (do_section_groups)
6686 printf (_("\nThere are no sections to group in this file.\n"));
6687
6688 return TRUE;
6689 }
6690
6691 if (filedata->section_headers == NULL)
6692 {
6693 error (_("Section headers are not available!\n"));
6694 /* PR 13622: This can happen with a corrupt ELF header. */
6695 return FALSE;
6696 }
6697
6698 section_headers_groups = (struct group **) calloc (filedata->file_header.e_shnum,
6699 sizeof (struct group *));
6700
6701 if (section_headers_groups == NULL)
6702 {
6703 error (_("Out of memory reading %u section group headers\n"),
6704 filedata->file_header.e_shnum);
6705 return FALSE;
6706 }
6707
6708 /* Scan the sections for the group section. */
6709 group_count = 0;
6710 for (i = 0, section = filedata->section_headers;
6711 i < filedata->file_header.e_shnum;
6712 i++, section++)
6713 if (section->sh_type == SHT_GROUP)
6714 group_count++;
6715
6716 if (group_count == 0)
6717 {
6718 if (do_section_groups)
6719 printf (_("\nThere are no section groups in this file.\n"));
6720
6721 return TRUE;
6722 }
6723
6724 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6725
6726 if (section_groups == NULL)
6727 {
6728 error (_("Out of memory reading %lu groups\n"),
6729 (unsigned long) group_count);
6730 return FALSE;
6731 }
6732
6733 symtab_sec = NULL;
6734 strtab_sec = NULL;
6735 symtab = NULL;
6736 num_syms = 0;
6737 strtab = NULL;
6738 strtab_size = 0;
6739 for (i = 0, section = filedata->section_headers, group = section_groups;
6740 i < filedata->file_header.e_shnum;
6741 i++, section++)
6742 {
6743 if (section->sh_type == SHT_GROUP)
6744 {
6745 const char * name = printable_section_name (filedata, section);
6746 const char * group_name;
6747 unsigned char * start;
6748 unsigned char * indices;
6749 unsigned int entry, j, size;
6750 Elf_Internal_Shdr * sec;
6751 Elf_Internal_Sym * sym;
6752
6753 /* Get the symbol table. */
6754 if (section->sh_link >= filedata->file_header.e_shnum
6755 || ((sec = filedata->section_headers + section->sh_link)->sh_type
6756 != SHT_SYMTAB))
6757 {
6758 error (_("Bad sh_link in group section `%s'\n"), name);
6759 continue;
6760 }
6761
6762 if (symtab_sec != sec)
6763 {
6764 symtab_sec = sec;
6765 if (symtab)
6766 free (symtab);
6767 symtab = GET_ELF_SYMBOLS (filedata, symtab_sec, & num_syms);
6768 }
6769
6770 if (symtab == NULL)
6771 {
6772 error (_("Corrupt header in group section `%s'\n"), name);
6773 continue;
6774 }
6775
6776 if (section->sh_info >= num_syms)
6777 {
6778 error (_("Bad sh_info in group section `%s'\n"), name);
6779 continue;
6780 }
6781
6782 sym = symtab + section->sh_info;
6783
6784 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6785 {
6786 if (sym->st_shndx == 0
6787 || sym->st_shndx >= filedata->file_header.e_shnum)
6788 {
6789 error (_("Bad sh_info in group section `%s'\n"), name);
6790 continue;
6791 }
6792
6793 group_name = SECTION_NAME (filedata->section_headers + sym->st_shndx);
6794 strtab_sec = NULL;
6795 if (strtab)
6796 free (strtab);
6797 strtab = NULL;
6798 strtab_size = 0;
6799 }
6800 else
6801 {
6802 /* Get the string table. */
6803 if (symtab_sec->sh_link >= filedata->file_header.e_shnum)
6804 {
6805 strtab_sec = NULL;
6806 if (strtab)
6807 free (strtab);
6808 strtab = NULL;
6809 strtab_size = 0;
6810 }
6811 else if (strtab_sec
6812 != (sec = filedata->section_headers + symtab_sec->sh_link))
6813 {
6814 strtab_sec = sec;
6815 if (strtab)
6816 free (strtab);
6817
6818 strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
6819 1, strtab_sec->sh_size,
6820 _("string table"));
6821 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6822 }
6823 group_name = sym->st_name < strtab_size
6824 ? strtab + sym->st_name : _("<corrupt>");
6825 }
6826
6827 /* PR 17531: file: loop. */
6828 if (section->sh_entsize > section->sh_size)
6829 {
6830 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6831 printable_section_name (filedata, section),
6832 (unsigned long) section->sh_entsize,
6833 (unsigned long) section->sh_size);
6834 break;
6835 }
6836
6837 start = (unsigned char *) get_data (NULL, filedata, section->sh_offset,
6838 1, section->sh_size,
6839 _("section data"));
6840 if (start == NULL)
6841 continue;
6842
6843 indices = start;
6844 size = (section->sh_size / section->sh_entsize) - 1;
6845 entry = byte_get (indices, 4);
6846 indices += 4;
6847
6848 if (do_section_groups)
6849 {
6850 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6851 get_group_flags (entry), i, name, group_name, size);
6852
6853 printf (_(" [Index] Name\n"));
6854 }
6855
6856 group->group_index = i;
6857
6858 for (j = 0; j < size; j++)
6859 {
6860 struct group_list * g;
6861
6862 entry = byte_get (indices, 4);
6863 indices += 4;
6864
6865 if (entry >= filedata->file_header.e_shnum)
6866 {
6867 static unsigned num_group_errors = 0;
6868
6869 if (num_group_errors ++ < 10)
6870 {
6871 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6872 entry, i, filedata->file_header.e_shnum - 1);
6873 if (num_group_errors == 10)
6874 warn (_("Further error messages about overlarge group section indices suppressed\n"));
6875 }
6876 continue;
6877 }
6878
6879 if (section_headers_groups [entry] != NULL)
6880 {
6881 if (entry)
6882 {
6883 static unsigned num_errs = 0;
6884
6885 if (num_errs ++ < 10)
6886 {
6887 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6888 entry, i,
6889 section_headers_groups [entry]->group_index);
6890 if (num_errs == 10)
6891 warn (_("Further error messages about already contained group sections suppressed\n"));
6892 }
6893 continue;
6894 }
6895 else
6896 {
6897 /* Intel C/C++ compiler may put section 0 in a
6898 section group. We just warn it the first time
6899 and ignore it afterwards. */
6900 static bfd_boolean warned = FALSE;
6901 if (!warned)
6902 {
6903 error (_("section 0 in group section [%5u]\n"),
6904 section_headers_groups [entry]->group_index);
6905 warned = TRUE;
6906 }
6907 }
6908 }
6909
6910 section_headers_groups [entry] = group;
6911
6912 if (do_section_groups)
6913 {
6914 sec = filedata->section_headers + entry;
6915 printf (" [%5u] %s\n", entry, printable_section_name (filedata, sec));
6916 }
6917
6918 g = (struct group_list *) xmalloc (sizeof (struct group_list));
6919 g->section_index = entry;
6920 g->next = group->root;
6921 group->root = g;
6922 }
6923
6924 if (start)
6925 free (start);
6926
6927 group++;
6928 }
6929 }
6930
6931 if (symtab)
6932 free (symtab);
6933 if (strtab)
6934 free (strtab);
6935 return TRUE;
6936 }
6937
6938 /* Data used to display dynamic fixups. */
6939
6940 struct ia64_vms_dynfixup
6941 {
6942 bfd_vma needed_ident; /* Library ident number. */
6943 bfd_vma needed; /* Index in the dstrtab of the library name. */
6944 bfd_vma fixup_needed; /* Index of the library. */
6945 bfd_vma fixup_rela_cnt; /* Number of fixups. */
6946 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
6947 };
6948
6949 /* Data used to display dynamic relocations. */
6950
6951 struct ia64_vms_dynimgrela
6952 {
6953 bfd_vma img_rela_cnt; /* Number of relocations. */
6954 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
6955 };
6956
6957 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6958 library). */
6959
6960 static bfd_boolean
6961 dump_ia64_vms_dynamic_fixups (Filedata * filedata,
6962 struct ia64_vms_dynfixup * fixup,
6963 const char * strtab,
6964 unsigned int strtab_sz)
6965 {
6966 Elf64_External_VMS_IMAGE_FIXUP * imfs;
6967 long i;
6968 const char * lib_name;
6969
6970 imfs = get_data (NULL, filedata, dynamic_addr + fixup->fixup_rela_off,
6971 1, fixup->fixup_rela_cnt * sizeof (*imfs),
6972 _("dynamic section image fixups"));
6973 if (!imfs)
6974 return FALSE;
6975
6976 if (fixup->needed < strtab_sz)
6977 lib_name = strtab + fixup->needed;
6978 else
6979 {
6980 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6981 (unsigned long) fixup->needed);
6982 lib_name = "???";
6983 }
6984 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6985 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6986 printf
6987 (_("Seg Offset Type SymVec DataType\n"));
6988
6989 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6990 {
6991 unsigned int type;
6992 const char *rtype;
6993
6994 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6995 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6996 type = BYTE_GET (imfs [i].type);
6997 rtype = elf_ia64_reloc_type (type);
6998 if (rtype == NULL)
6999 printf (" 0x%08x ", type);
7000 else
7001 printf (" %-32s ", rtype);
7002 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
7003 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
7004 }
7005
7006 free (imfs);
7007 return TRUE;
7008 }
7009
7010 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7011
7012 static bfd_boolean
7013 dump_ia64_vms_dynamic_relocs (Filedata * filedata, struct ia64_vms_dynimgrela *imgrela)
7014 {
7015 Elf64_External_VMS_IMAGE_RELA *imrs;
7016 long i;
7017
7018 imrs = get_data (NULL, filedata, dynamic_addr + imgrela->img_rela_off,
7019 1, imgrela->img_rela_cnt * sizeof (*imrs),
7020 _("dynamic section image relocations"));
7021 if (!imrs)
7022 return FALSE;
7023
7024 printf (_("\nImage relocs\n"));
7025 printf
7026 (_("Seg Offset Type Addend Seg Sym Off\n"));
7027
7028 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
7029 {
7030 unsigned int type;
7031 const char *rtype;
7032
7033 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
7034 printf ("%08" BFD_VMA_FMT "x ",
7035 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
7036 type = BYTE_GET (imrs [i].type);
7037 rtype = elf_ia64_reloc_type (type);
7038 if (rtype == NULL)
7039 printf ("0x%08x ", type);
7040 else
7041 printf ("%-31s ", rtype);
7042 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
7043 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
7044 printf ("%08" BFD_VMA_FMT "x\n",
7045 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
7046 }
7047
7048 free (imrs);
7049 return TRUE;
7050 }
7051
7052 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7053
7054 static bfd_boolean
7055 process_ia64_vms_dynamic_relocs (Filedata * filedata)
7056 {
7057 struct ia64_vms_dynfixup fixup;
7058 struct ia64_vms_dynimgrela imgrela;
7059 Elf_Internal_Dyn *entry;
7060 bfd_vma strtab_off = 0;
7061 bfd_vma strtab_sz = 0;
7062 char *strtab = NULL;
7063 bfd_boolean res = TRUE;
7064
7065 memset (&fixup, 0, sizeof (fixup));
7066 memset (&imgrela, 0, sizeof (imgrela));
7067
7068 /* Note: the order of the entries is specified by the OpenVMS specs. */
7069 for (entry = dynamic_section;
7070 entry < dynamic_section + dynamic_nent;
7071 entry++)
7072 {
7073 switch (entry->d_tag)
7074 {
7075 case DT_IA_64_VMS_STRTAB_OFFSET:
7076 strtab_off = entry->d_un.d_val;
7077 break;
7078 case DT_STRSZ:
7079 strtab_sz = entry->d_un.d_val;
7080 if (strtab == NULL)
7081 strtab = get_data (NULL, filedata, dynamic_addr + strtab_off,
7082 1, strtab_sz, _("dynamic string section"));
7083 break;
7084
7085 case DT_IA_64_VMS_NEEDED_IDENT:
7086 fixup.needed_ident = entry->d_un.d_val;
7087 break;
7088 case DT_NEEDED:
7089 fixup.needed = entry->d_un.d_val;
7090 break;
7091 case DT_IA_64_VMS_FIXUP_NEEDED:
7092 fixup.fixup_needed = entry->d_un.d_val;
7093 break;
7094 case DT_IA_64_VMS_FIXUP_RELA_CNT:
7095 fixup.fixup_rela_cnt = entry->d_un.d_val;
7096 break;
7097 case DT_IA_64_VMS_FIXUP_RELA_OFF:
7098 fixup.fixup_rela_off = entry->d_un.d_val;
7099 if (! dump_ia64_vms_dynamic_fixups (filedata, &fixup, strtab, strtab_sz))
7100 res = FALSE;
7101 break;
7102 case DT_IA_64_VMS_IMG_RELA_CNT:
7103 imgrela.img_rela_cnt = entry->d_un.d_val;
7104 break;
7105 case DT_IA_64_VMS_IMG_RELA_OFF:
7106 imgrela.img_rela_off = entry->d_un.d_val;
7107 if (! dump_ia64_vms_dynamic_relocs (filedata, &imgrela))
7108 res = FALSE;
7109 break;
7110
7111 default:
7112 break;
7113 }
7114 }
7115
7116 if (strtab != NULL)
7117 free (strtab);
7118
7119 return res;
7120 }
7121
7122 static struct
7123 {
7124 const char * name;
7125 int reloc;
7126 int size;
7127 int rela;
7128 }
7129 dynamic_relocations [] =
7130 {
7131 { "REL", DT_REL, DT_RELSZ, FALSE },
7132 { "RELA", DT_RELA, DT_RELASZ, TRUE },
7133 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
7134 };
7135
7136 /* Process the reloc section. */
7137
7138 static bfd_boolean
7139 process_relocs (Filedata * filedata)
7140 {
7141 unsigned long rel_size;
7142 unsigned long rel_offset;
7143
7144 if (!do_reloc)
7145 return TRUE;
7146
7147 if (do_using_dynamic)
7148 {
7149 int is_rela;
7150 const char * name;
7151 bfd_boolean has_dynamic_reloc;
7152 unsigned int i;
7153
7154 has_dynamic_reloc = FALSE;
7155
7156 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7157 {
7158 is_rela = dynamic_relocations [i].rela;
7159 name = dynamic_relocations [i].name;
7160 rel_size = dynamic_info [dynamic_relocations [i].size];
7161 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
7162
7163 if (rel_size)
7164 has_dynamic_reloc = TRUE;
7165
7166 if (is_rela == UNKNOWN)
7167 {
7168 if (dynamic_relocations [i].reloc == DT_JMPREL)
7169 switch (dynamic_info[DT_PLTREL])
7170 {
7171 case DT_REL:
7172 is_rela = FALSE;
7173 break;
7174 case DT_RELA:
7175 is_rela = TRUE;
7176 break;
7177 }
7178 }
7179
7180 if (rel_size)
7181 {
7182 printf
7183 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7184 name, rel_offset, rel_size);
7185
7186 dump_relocations (filedata,
7187 offset_from_vma (filedata, rel_offset, rel_size),
7188 rel_size,
7189 dynamic_symbols, num_dynamic_syms,
7190 dynamic_strings, dynamic_strings_length,
7191 is_rela, TRUE /* is_dynamic */);
7192 }
7193 }
7194
7195 if (is_ia64_vms (filedata))
7196 if (process_ia64_vms_dynamic_relocs (filedata))
7197 has_dynamic_reloc = TRUE;
7198
7199 if (! has_dynamic_reloc)
7200 printf (_("\nThere are no dynamic relocations in this file.\n"));
7201 }
7202 else
7203 {
7204 Elf_Internal_Shdr * section;
7205 unsigned long i;
7206 bfd_boolean found = FALSE;
7207
7208 for (i = 0, section = filedata->section_headers;
7209 i < filedata->file_header.e_shnum;
7210 i++, section++)
7211 {
7212 if ( section->sh_type != SHT_RELA
7213 && section->sh_type != SHT_REL)
7214 continue;
7215
7216 rel_offset = section->sh_offset;
7217 rel_size = section->sh_size;
7218
7219 if (rel_size)
7220 {
7221 Elf_Internal_Shdr * strsec;
7222 int is_rela;
7223 unsigned long num_rela;
7224
7225 printf (_("\nRelocation section "));
7226
7227 if (filedata->string_table == NULL)
7228 printf ("%d", section->sh_name);
7229 else
7230 printf ("'%s'", printable_section_name (filedata, section));
7231
7232 num_rela = rel_size / section->sh_entsize;
7233 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7234 " at offset 0x%lx contains %lu entries:\n",
7235 num_rela),
7236 rel_offset, num_rela);
7237
7238 is_rela = section->sh_type == SHT_RELA;
7239
7240 if (section->sh_link != 0
7241 && section->sh_link < filedata->file_header.e_shnum)
7242 {
7243 Elf_Internal_Shdr * symsec;
7244 Elf_Internal_Sym * symtab;
7245 unsigned long nsyms;
7246 unsigned long strtablen = 0;
7247 char * strtab = NULL;
7248
7249 symsec = filedata->section_headers + section->sh_link;
7250 if (symsec->sh_type != SHT_SYMTAB
7251 && symsec->sh_type != SHT_DYNSYM)
7252 continue;
7253
7254 symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
7255
7256 if (symtab == NULL)
7257 continue;
7258
7259 if (symsec->sh_link != 0
7260 && symsec->sh_link < filedata->file_header.e_shnum)
7261 {
7262 strsec = filedata->section_headers + symsec->sh_link;
7263
7264 strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7265 1, strsec->sh_size,
7266 _("string table"));
7267 strtablen = strtab == NULL ? 0 : strsec->sh_size;
7268 }
7269
7270 dump_relocations (filedata, rel_offset, rel_size,
7271 symtab, nsyms, strtab, strtablen,
7272 is_rela,
7273 symsec->sh_type == SHT_DYNSYM);
7274 if (strtab)
7275 free (strtab);
7276 free (symtab);
7277 }
7278 else
7279 dump_relocations (filedata, rel_offset, rel_size,
7280 NULL, 0, NULL, 0, is_rela,
7281 FALSE /* is_dynamic */);
7282
7283 found = TRUE;
7284 }
7285 }
7286
7287 if (! found)
7288 {
7289 /* Users sometimes forget the -D option, so try to be helpful. */
7290 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
7291 {
7292 if (dynamic_info [dynamic_relocations [i].size])
7293 {
7294 printf (_("\nThere are no static relocations in this file."));
7295 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7296
7297 break;
7298 }
7299 }
7300 if (i == ARRAY_SIZE (dynamic_relocations))
7301 printf (_("\nThere are no relocations in this file.\n"));
7302 }
7303 }
7304
7305 return TRUE;
7306 }
7307
7308 /* An absolute address consists of a section and an offset. If the
7309 section is NULL, the offset itself is the address, otherwise, the
7310 address equals to LOAD_ADDRESS(section) + offset. */
7311
7312 struct absaddr
7313 {
7314 unsigned short section;
7315 bfd_vma offset;
7316 };
7317
7318 #define ABSADDR(a) \
7319 ((a).section \
7320 ? filedata->section_headers [(a).section].sh_addr + (a).offset \
7321 : (a).offset)
7322
7323 /* Find the nearest symbol at or below ADDR. Returns the symbol
7324 name, if found, and the offset from the symbol to ADDR. */
7325
7326 static void
7327 find_symbol_for_address (Filedata * filedata,
7328 Elf_Internal_Sym * symtab,
7329 unsigned long nsyms,
7330 const char * strtab,
7331 unsigned long strtab_size,
7332 struct absaddr addr,
7333 const char ** symname,
7334 bfd_vma * offset)
7335 {
7336 bfd_vma dist = 0x100000;
7337 Elf_Internal_Sym * sym;
7338 Elf_Internal_Sym * beg;
7339 Elf_Internal_Sym * end;
7340 Elf_Internal_Sym * best = NULL;
7341
7342 REMOVE_ARCH_BITS (addr.offset);
7343 beg = symtab;
7344 end = symtab + nsyms;
7345
7346 while (beg < end)
7347 {
7348 bfd_vma value;
7349
7350 sym = beg + (end - beg) / 2;
7351
7352 value = sym->st_value;
7353 REMOVE_ARCH_BITS (value);
7354
7355 if (sym->st_name != 0
7356 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
7357 && addr.offset >= value
7358 && addr.offset - value < dist)
7359 {
7360 best = sym;
7361 dist = addr.offset - value;
7362 if (!dist)
7363 break;
7364 }
7365
7366 if (addr.offset < value)
7367 end = sym;
7368 else
7369 beg = sym + 1;
7370 }
7371
7372 if (best)
7373 {
7374 *symname = (best->st_name >= strtab_size
7375 ? _("<corrupt>") : strtab + best->st_name);
7376 *offset = dist;
7377 return;
7378 }
7379
7380 *symname = NULL;
7381 *offset = addr.offset;
7382 }
7383
7384 static /* signed */ int
7385 symcmp (const void *p, const void *q)
7386 {
7387 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7388 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7389
7390 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7391 }
7392
7393 /* Process the unwind section. */
7394
7395 #include "unwind-ia64.h"
7396
7397 struct ia64_unw_table_entry
7398 {
7399 struct absaddr start;
7400 struct absaddr end;
7401 struct absaddr info;
7402 };
7403
7404 struct ia64_unw_aux_info
7405 {
7406 struct ia64_unw_table_entry * table; /* Unwind table. */
7407 unsigned long table_len; /* Length of unwind table. */
7408 unsigned char * info; /* Unwind info. */
7409 unsigned long info_size; /* Size of unwind info. */
7410 bfd_vma info_addr; /* Starting address of unwind info. */
7411 bfd_vma seg_base; /* Starting address of segment. */
7412 Elf_Internal_Sym * symtab; /* The symbol table. */
7413 unsigned long nsyms; /* Number of symbols. */
7414 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7415 unsigned long nfuns; /* Number of entries in funtab. */
7416 char * strtab; /* The string table. */
7417 unsigned long strtab_size; /* Size of string table. */
7418 };
7419
7420 static bfd_boolean
7421 dump_ia64_unwind (Filedata * filedata, struct ia64_unw_aux_info * aux)
7422 {
7423 struct ia64_unw_table_entry * tp;
7424 unsigned long j, nfuns;
7425 int in_body;
7426 bfd_boolean res = TRUE;
7427
7428 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7429 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7430 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7431 aux->funtab[nfuns++] = aux->symtab[j];
7432 aux->nfuns = nfuns;
7433 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7434
7435 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7436 {
7437 bfd_vma stamp;
7438 bfd_vma offset;
7439 const unsigned char * dp;
7440 const unsigned char * head;
7441 const unsigned char * end;
7442 const char * procname;
7443
7444 find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7445 aux->strtab_size, tp->start, &procname, &offset);
7446
7447 fputs ("\n<", stdout);
7448
7449 if (procname)
7450 {
7451 fputs (procname, stdout);
7452
7453 if (offset)
7454 printf ("+%lx", (unsigned long) offset);
7455 }
7456
7457 fputs (">: [", stdout);
7458 print_vma (tp->start.offset, PREFIX_HEX);
7459 fputc ('-', stdout);
7460 print_vma (tp->end.offset, PREFIX_HEX);
7461 printf ("], info at +0x%lx\n",
7462 (unsigned long) (tp->info.offset - aux->seg_base));
7463
7464 /* PR 17531: file: 86232b32. */
7465 if (aux->info == NULL)
7466 continue;
7467
7468 /* PR 17531: file: 0997b4d1. */
7469 if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
7470 {
7471 warn (_("Invalid offset %lx in table entry %ld\n"),
7472 (long) tp->info.offset, (long) (tp - aux->table));
7473 res = FALSE;
7474 continue;
7475 }
7476
7477 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
7478 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
7479
7480 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7481 (unsigned) UNW_VER (stamp),
7482 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7483 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7484 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
7485 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
7486
7487 if (UNW_VER (stamp) != 1)
7488 {
7489 printf (_("\tUnknown version.\n"));
7490 continue;
7491 }
7492
7493 in_body = 0;
7494 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7495 /* PR 17531: file: 16ceda89. */
7496 if (end > aux->info + aux->info_size)
7497 end = aux->info + aux->info_size;
7498 for (dp = head + 8; dp < end;)
7499 dp = unw_decode (dp, in_body, & in_body, end);
7500 }
7501
7502 free (aux->funtab);
7503
7504 return res;
7505 }
7506
7507 static bfd_boolean
7508 slurp_ia64_unwind_table (Filedata * filedata,
7509 struct ia64_unw_aux_info * aux,
7510 Elf_Internal_Shdr * sec)
7511 {
7512 unsigned long size, nrelas, i;
7513 Elf_Internal_Phdr * seg;
7514 struct ia64_unw_table_entry * tep;
7515 Elf_Internal_Shdr * relsec;
7516 Elf_Internal_Rela * rela;
7517 Elf_Internal_Rela * rp;
7518 unsigned char * table;
7519 unsigned char * tp;
7520 Elf_Internal_Sym * sym;
7521 const char * relname;
7522
7523 aux->table_len = 0;
7524
7525 /* First, find the starting address of the segment that includes
7526 this section: */
7527
7528 if (filedata->file_header.e_phnum)
7529 {
7530 if (! get_program_headers (filedata))
7531 return FALSE;
7532
7533 for (seg = filedata->program_headers;
7534 seg < filedata->program_headers + filedata->file_header.e_phnum;
7535 ++seg)
7536 {
7537 if (seg->p_type != PT_LOAD)
7538 continue;
7539
7540 if (sec->sh_addr >= seg->p_vaddr
7541 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7542 {
7543 aux->seg_base = seg->p_vaddr;
7544 break;
7545 }
7546 }
7547 }
7548
7549 /* Second, build the unwind table from the contents of the unwind section: */
7550 size = sec->sh_size;
7551 table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7552 _("unwind table"));
7553 if (!table)
7554 return FALSE;
7555
7556 aux->table_len = size / (3 * eh_addr_size);
7557 aux->table = (struct ia64_unw_table_entry *)
7558 xcmalloc (aux->table_len, sizeof (aux->table[0]));
7559 tep = aux->table;
7560
7561 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7562 {
7563 tep->start.section = SHN_UNDEF;
7564 tep->end.section = SHN_UNDEF;
7565 tep->info.section = SHN_UNDEF;
7566 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7567 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7568 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7569 tep->start.offset += aux->seg_base;
7570 tep->end.offset += aux->seg_base;
7571 tep->info.offset += aux->seg_base;
7572 }
7573 free (table);
7574
7575 /* Third, apply any relocations to the unwind table: */
7576 for (relsec = filedata->section_headers;
7577 relsec < filedata->section_headers + filedata->file_header.e_shnum;
7578 ++relsec)
7579 {
7580 if (relsec->sh_type != SHT_RELA
7581 || relsec->sh_info >= filedata->file_header.e_shnum
7582 || filedata->section_headers + relsec->sh_info != sec)
7583 continue;
7584
7585 if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
7586 & rela, & nrelas))
7587 {
7588 free (aux->table);
7589 aux->table = NULL;
7590 aux->table_len = 0;
7591 return FALSE;
7592 }
7593
7594 for (rp = rela; rp < rela + nrelas; ++rp)
7595 {
7596 relname = elf_ia64_reloc_type (get_reloc_type (filedata, rp->r_info));
7597 sym = aux->symtab + get_reloc_symindex (rp->r_info);
7598
7599 /* PR 17531: file: 9fa67536. */
7600 if (relname == NULL)
7601 {
7602 warn (_("Skipping unknown relocation type: %u\n"),
7603 get_reloc_type (filedata, rp->r_info));
7604 continue;
7605 }
7606
7607 if (! const_strneq (relname, "R_IA64_SEGREL"))
7608 {
7609 warn (_("Skipping unexpected relocation type: %s\n"), relname);
7610 continue;
7611 }
7612
7613 i = rp->r_offset / (3 * eh_addr_size);
7614
7615 /* PR 17531: file: 5bc8d9bf. */
7616 if (i >= aux->table_len)
7617 {
7618 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7619 continue;
7620 }
7621
7622 switch (rp->r_offset / eh_addr_size % 3)
7623 {
7624 case 0:
7625 aux->table[i].start.section = sym->st_shndx;
7626 aux->table[i].start.offset = rp->r_addend + sym->st_value;
7627 break;
7628 case 1:
7629 aux->table[i].end.section = sym->st_shndx;
7630 aux->table[i].end.offset = rp->r_addend + sym->st_value;
7631 break;
7632 case 2:
7633 aux->table[i].info.section = sym->st_shndx;
7634 aux->table[i].info.offset = rp->r_addend + sym->st_value;
7635 break;
7636 default:
7637 break;
7638 }
7639 }
7640
7641 free (rela);
7642 }
7643
7644 return TRUE;
7645 }
7646
7647 static bfd_boolean
7648 ia64_process_unwind (Filedata * filedata)
7649 {
7650 Elf_Internal_Shdr * sec;
7651 Elf_Internal_Shdr * unwsec = NULL;
7652 Elf_Internal_Shdr * strsec;
7653 unsigned long i, unwcount = 0, unwstart = 0;
7654 struct ia64_unw_aux_info aux;
7655 bfd_boolean res = TRUE;
7656
7657 memset (& aux, 0, sizeof (aux));
7658
7659 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
7660 {
7661 if (sec->sh_type == SHT_SYMTAB
7662 && sec->sh_link < filedata->file_header.e_shnum)
7663 {
7664 aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
7665
7666 strsec = filedata->section_headers + sec->sh_link;
7667 if (aux.strtab != NULL)
7668 {
7669 error (_("Multiple auxillary string tables encountered\n"));
7670 free (aux.strtab);
7671 res = FALSE;
7672 }
7673 aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
7674 1, strsec->sh_size,
7675 _("string table"));
7676 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7677 }
7678 else if (sec->sh_type == SHT_IA_64_UNWIND)
7679 unwcount++;
7680 }
7681
7682 if (!unwcount)
7683 printf (_("\nThere are no unwind sections in this file.\n"));
7684
7685 while (unwcount-- > 0)
7686 {
7687 char * suffix;
7688 size_t len, len2;
7689
7690 for (i = unwstart, sec = filedata->section_headers + unwstart, unwsec = NULL;
7691 i < filedata->file_header.e_shnum; ++i, ++sec)
7692 if (sec->sh_type == SHT_IA_64_UNWIND)
7693 {
7694 unwsec = sec;
7695 break;
7696 }
7697 /* We have already counted the number of SHT_IA64_UNWIND
7698 sections so the loop above should never fail. */
7699 assert (unwsec != NULL);
7700
7701 unwstart = i + 1;
7702 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7703
7704 if ((unwsec->sh_flags & SHF_GROUP) != 0)
7705 {
7706 /* We need to find which section group it is in. */
7707 struct group_list * g;
7708
7709 if (section_headers_groups == NULL
7710 || section_headers_groups [i] == NULL)
7711 i = filedata->file_header.e_shnum;
7712 else
7713 {
7714 g = section_headers_groups [i]->root;
7715
7716 for (; g != NULL; g = g->next)
7717 {
7718 sec = filedata->section_headers + g->section_index;
7719
7720 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7721 break;
7722 }
7723
7724 if (g == NULL)
7725 i = filedata->file_header.e_shnum;
7726 }
7727 }
7728 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7729 {
7730 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7731 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7732 suffix = SECTION_NAME (unwsec) + len;
7733 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7734 ++i, ++sec)
7735 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7736 && streq (SECTION_NAME (sec) + len2, suffix))
7737 break;
7738 }
7739 else
7740 {
7741 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7742 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7743 len = sizeof (ELF_STRING_ia64_unwind) - 1;
7744 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7745 suffix = "";
7746 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7747 suffix = SECTION_NAME (unwsec) + len;
7748 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum;
7749 ++i, ++sec)
7750 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7751 && streq (SECTION_NAME (sec) + len2, suffix))
7752 break;
7753 }
7754
7755 if (i == filedata->file_header.e_shnum)
7756 {
7757 printf (_("\nCould not find unwind info section for "));
7758
7759 if (filedata->string_table == NULL)
7760 printf ("%d", unwsec->sh_name);
7761 else
7762 printf ("'%s'", printable_section_name (filedata, unwsec));
7763 }
7764 else
7765 {
7766 aux.info_addr = sec->sh_addr;
7767 aux.info = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1,
7768 sec->sh_size,
7769 _("unwind info"));
7770 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7771
7772 printf (_("\nUnwind section "));
7773
7774 if (filedata->string_table == NULL)
7775 printf ("%d", unwsec->sh_name);
7776 else
7777 printf ("'%s'", printable_section_name (filedata, unwsec));
7778
7779 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7780 (unsigned long) unwsec->sh_offset,
7781 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7782
7783 if (slurp_ia64_unwind_table (filedata, & aux, unwsec)
7784 && aux.table_len > 0)
7785 dump_ia64_unwind (filedata, & aux);
7786
7787 if (aux.table)
7788 free ((char *) aux.table);
7789 if (aux.info)
7790 free ((char *) aux.info);
7791 aux.table = NULL;
7792 aux.info = NULL;
7793 }
7794 }
7795
7796 if (aux.symtab)
7797 free (aux.symtab);
7798 if (aux.strtab)
7799 free ((char *) aux.strtab);
7800
7801 return res;
7802 }
7803
7804 struct hppa_unw_table_entry
7805 {
7806 struct absaddr start;
7807 struct absaddr end;
7808 unsigned int Cannot_unwind:1; /* 0 */
7809 unsigned int Millicode:1; /* 1 */
7810 unsigned int Millicode_save_sr0:1; /* 2 */
7811 unsigned int Region_description:2; /* 3..4 */
7812 unsigned int reserved1:1; /* 5 */
7813 unsigned int Entry_SR:1; /* 6 */
7814 unsigned int Entry_FR:4; /* Number saved 7..10 */
7815 unsigned int Entry_GR:5; /* Number saved 11..15 */
7816 unsigned int Args_stored:1; /* 16 */
7817 unsigned int Variable_Frame:1; /* 17 */
7818 unsigned int Separate_Package_Body:1; /* 18 */
7819 unsigned int Frame_Extension_Millicode:1; /* 19 */
7820 unsigned int Stack_Overflow_Check:1; /* 20 */
7821 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
7822 unsigned int Ada_Region:1; /* 22 */
7823 unsigned int cxx_info:1; /* 23 */
7824 unsigned int cxx_try_catch:1; /* 24 */
7825 unsigned int sched_entry_seq:1; /* 25 */
7826 unsigned int reserved2:1; /* 26 */
7827 unsigned int Save_SP:1; /* 27 */
7828 unsigned int Save_RP:1; /* 28 */
7829 unsigned int Save_MRP_in_frame:1; /* 29 */
7830 unsigned int extn_ptr_defined:1; /* 30 */
7831 unsigned int Cleanup_defined:1; /* 31 */
7832
7833 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
7834 unsigned int HP_UX_interrupt_marker:1; /* 1 */
7835 unsigned int Large_frame:1; /* 2 */
7836 unsigned int Pseudo_SP_Set:1; /* 3 */
7837 unsigned int reserved4:1; /* 4 */
7838 unsigned int Total_frame_size:27; /* 5..31 */
7839 };
7840
7841 struct hppa_unw_aux_info
7842 {
7843 struct hppa_unw_table_entry * table; /* Unwind table. */
7844 unsigned long table_len; /* Length of unwind table. */
7845 bfd_vma seg_base; /* Starting address of segment. */
7846 Elf_Internal_Sym * symtab; /* The symbol table. */
7847 unsigned long nsyms; /* Number of symbols. */
7848 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7849 unsigned long nfuns; /* Number of entries in funtab. */
7850 char * strtab; /* The string table. */
7851 unsigned long strtab_size; /* Size of string table. */
7852 };
7853
7854 static bfd_boolean
7855 dump_hppa_unwind (Filedata * filedata, struct hppa_unw_aux_info * aux)
7856 {
7857 struct hppa_unw_table_entry * tp;
7858 unsigned long j, nfuns;
7859 bfd_boolean res = TRUE;
7860
7861 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7862 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7863 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7864 aux->funtab[nfuns++] = aux->symtab[j];
7865 aux->nfuns = nfuns;
7866 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7867
7868 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7869 {
7870 bfd_vma offset;
7871 const char * procname;
7872
7873 find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
7874 aux->strtab_size, tp->start, &procname,
7875 &offset);
7876
7877 fputs ("\n<", stdout);
7878
7879 if (procname)
7880 {
7881 fputs (procname, stdout);
7882
7883 if (offset)
7884 printf ("+%lx", (unsigned long) offset);
7885 }
7886
7887 fputs (">: [", stdout);
7888 print_vma (tp->start.offset, PREFIX_HEX);
7889 fputc ('-', stdout);
7890 print_vma (tp->end.offset, PREFIX_HEX);
7891 printf ("]\n\t");
7892
7893 #define PF(_m) if (tp->_m) printf (#_m " ");
7894 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7895 PF(Cannot_unwind);
7896 PF(Millicode);
7897 PF(Millicode_save_sr0);
7898 /* PV(Region_description); */
7899 PF(Entry_SR);
7900 PV(Entry_FR);
7901 PV(Entry_GR);
7902 PF(Args_stored);
7903 PF(Variable_Frame);
7904 PF(Separate_Package_Body);
7905 PF(Frame_Extension_Millicode);
7906 PF(Stack_Overflow_Check);
7907 PF(Two_Instruction_SP_Increment);
7908 PF(Ada_Region);
7909 PF(cxx_info);
7910 PF(cxx_try_catch);
7911 PF(sched_entry_seq);
7912 PF(Save_SP);
7913 PF(Save_RP);
7914 PF(Save_MRP_in_frame);
7915 PF(extn_ptr_defined);
7916 PF(Cleanup_defined);
7917 PF(MPE_XL_interrupt_marker);
7918 PF(HP_UX_interrupt_marker);
7919 PF(Large_frame);
7920 PF(Pseudo_SP_Set);
7921 PV(Total_frame_size);
7922 #undef PF
7923 #undef PV
7924 }
7925
7926 printf ("\n");
7927
7928 free (aux->funtab);
7929
7930 return res;
7931 }
7932
7933 static bfd_boolean
7934 slurp_hppa_unwind_table (Filedata * filedata,
7935 struct hppa_unw_aux_info * aux,
7936 Elf_Internal_Shdr * sec)
7937 {
7938 unsigned long size, unw_ent_size, nentries, nrelas, i;
7939 Elf_Internal_Phdr * seg;
7940 struct hppa_unw_table_entry * tep;
7941 Elf_Internal_Shdr * relsec;
7942 Elf_Internal_Rela * rela;
7943 Elf_Internal_Rela * rp;
7944 unsigned char * table;
7945 unsigned char * tp;
7946 Elf_Internal_Sym * sym;
7947 const char * relname;
7948
7949 /* First, find the starting address of the segment that includes
7950 this section. */
7951 if (filedata->file_header.e_phnum)
7952 {
7953 if (! get_program_headers (filedata))
7954 return FALSE;
7955
7956 for (seg = filedata->program_headers;
7957 seg < filedata->program_headers + filedata->file_header.e_phnum;
7958 ++seg)
7959 {
7960 if (seg->p_type != PT_LOAD)
7961 continue;
7962
7963 if (sec->sh_addr >= seg->p_vaddr
7964 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7965 {
7966 aux->seg_base = seg->p_vaddr;
7967 break;
7968 }
7969 }
7970 }
7971
7972 /* Second, build the unwind table from the contents of the unwind
7973 section. */
7974 size = sec->sh_size;
7975 table = (unsigned char *) get_data (NULL, filedata, sec->sh_offset, 1, size,
7976 _("unwind table"));
7977 if (!table)
7978 return FALSE;
7979
7980 unw_ent_size = 16;
7981 nentries = size / unw_ent_size;
7982 size = unw_ent_size * nentries;
7983
7984 tep = aux->table = (struct hppa_unw_table_entry *)
7985 xcmalloc (nentries, sizeof (aux->table[0]));
7986
7987 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
7988 {
7989 unsigned int tmp1, tmp2;
7990
7991 tep->start.section = SHN_UNDEF;
7992 tep->end.section = SHN_UNDEF;
7993
7994 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7995 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7996 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7997 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7998
7999 tep->start.offset += aux->seg_base;
8000 tep->end.offset += aux->seg_base;
8001
8002 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
8003 tep->Millicode = (tmp1 >> 30) & 0x1;
8004 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
8005 tep->Region_description = (tmp1 >> 27) & 0x3;
8006 tep->reserved1 = (tmp1 >> 26) & 0x1;
8007 tep->Entry_SR = (tmp1 >> 25) & 0x1;
8008 tep->Entry_FR = (tmp1 >> 21) & 0xf;
8009 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
8010 tep->Args_stored = (tmp1 >> 15) & 0x1;
8011 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
8012 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
8013 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
8014 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
8015 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
8016 tep->Ada_Region = (tmp1 >> 9) & 0x1;
8017 tep->cxx_info = (tmp1 >> 8) & 0x1;
8018 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
8019 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
8020 tep->reserved2 = (tmp1 >> 5) & 0x1;
8021 tep->Save_SP = (tmp1 >> 4) & 0x1;
8022 tep->Save_RP = (tmp1 >> 3) & 0x1;
8023 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
8024 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
8025 tep->Cleanup_defined = tmp1 & 0x1;
8026
8027 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
8028 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
8029 tep->Large_frame = (tmp2 >> 29) & 0x1;
8030 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
8031 tep->reserved4 = (tmp2 >> 27) & 0x1;
8032 tep->Total_frame_size = tmp2 & 0x7ffffff;
8033 }
8034 free (table);
8035
8036 /* Third, apply any relocations to the unwind table. */
8037 for (relsec = filedata->section_headers;
8038 relsec < filedata->section_headers + filedata->file_header.e_shnum;
8039 ++relsec)
8040 {
8041 if (relsec->sh_type != SHT_RELA
8042 || relsec->sh_info >= filedata->file_header.e_shnum
8043 || filedata->section_headers + relsec->sh_info != sec)
8044 continue;
8045
8046 if (!slurp_rela_relocs (filedata, relsec->sh_offset, relsec->sh_size,
8047 & rela, & nrelas))
8048 return FALSE;
8049
8050 for (rp = rela; rp < rela + nrelas; ++rp)
8051 {
8052 relname = elf_hppa_reloc_type (get_reloc_type (filedata, rp->r_info));
8053 sym = aux->symtab + get_reloc_symindex (rp->r_info);
8054
8055 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8056 if (! const_strneq (relname, "R_PARISC_SEGREL"))
8057 {
8058 warn (_("Skipping unexpected relocation type %s\n"), relname);
8059 continue;
8060 }
8061
8062 i = rp->r_offset / unw_ent_size;
8063
8064 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
8065 {
8066 case 0:
8067 aux->table[i].start.section = sym->st_shndx;
8068 aux->table[i].start.offset = sym->st_value + rp->r_addend;
8069 break;
8070 case 1:
8071 aux->table[i].end.section = sym->st_shndx;
8072 aux->table[i].end.offset = sym->st_value + rp->r_addend;
8073 break;
8074 default:
8075 break;
8076 }
8077 }
8078
8079 free (rela);
8080 }
8081
8082 aux->table_len = nentries;
8083
8084 return TRUE;
8085 }
8086
8087 static bfd_boolean
8088 hppa_process_unwind (Filedata * filedata)
8089 {
8090 struct hppa_unw_aux_info aux;
8091 Elf_Internal_Shdr * unwsec = NULL;
8092 Elf_Internal_Shdr * strsec;
8093 Elf_Internal_Shdr * sec;
8094 unsigned long i;
8095 bfd_boolean res = TRUE;
8096
8097 if (filedata->string_table == NULL)
8098 return FALSE;
8099
8100 memset (& aux, 0, sizeof (aux));
8101
8102 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8103 {
8104 if (sec->sh_type == SHT_SYMTAB
8105 && sec->sh_link < filedata->file_header.e_shnum)
8106 {
8107 aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
8108
8109 strsec = filedata->section_headers + sec->sh_link;
8110 if (aux.strtab != NULL)
8111 {
8112 error (_("Multiple auxillary string tables encountered\n"));
8113 free (aux.strtab);
8114 res = FALSE;
8115 }
8116 aux.strtab = (char *) get_data (NULL, filedata, strsec->sh_offset,
8117 1, strsec->sh_size,
8118 _("string table"));
8119 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8120 }
8121 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8122 unwsec = sec;
8123 }
8124
8125 if (!unwsec)
8126 printf (_("\nThere are no unwind sections in this file.\n"));
8127
8128 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
8129 {
8130 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
8131 {
8132 unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size + 8);
8133
8134 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8135 "contains %lu entry:\n",
8136 "\nUnwind section '%s' at offset 0x%lx "
8137 "contains %lu entries:\n",
8138 num_unwind),
8139 printable_section_name (filedata, sec),
8140 (unsigned long) sec->sh_offset,
8141 num_unwind);
8142
8143 if (! slurp_hppa_unwind_table (filedata, &aux, sec))
8144 res = FALSE;
8145
8146 if (res && aux.table_len > 0)
8147 {
8148 if (! dump_hppa_unwind (filedata, &aux))
8149 res = FALSE;
8150 }
8151
8152 if (aux.table)
8153 free ((char *) aux.table);
8154 aux.table = NULL;
8155 }
8156 }
8157
8158 if (aux.symtab)
8159 free (aux.symtab);
8160 if (aux.strtab)
8161 free ((char *) aux.strtab);
8162
8163 return res;
8164 }
8165
8166 struct arm_section
8167 {
8168 unsigned char * data; /* The unwind data. */
8169 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
8170 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
8171 unsigned long nrelas; /* The number of relocations. */
8172 unsigned int rel_type; /* REL or RELA ? */
8173 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
8174 };
8175
8176 struct arm_unw_aux_info
8177 {
8178 Filedata * filedata; /* The file containing the unwind sections. */
8179 Elf_Internal_Sym * symtab; /* The file's symbol table. */
8180 unsigned long nsyms; /* Number of symbols. */
8181 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
8182 unsigned long nfuns; /* Number of these symbols. */
8183 char * strtab; /* The file's string table. */
8184 unsigned long strtab_size; /* Size of string table. */
8185 };
8186
8187 static const char *
8188 arm_print_vma_and_name (Filedata * filedata,
8189 struct arm_unw_aux_info * aux,
8190 bfd_vma fn,
8191 struct absaddr addr)
8192 {
8193 const char *procname;
8194 bfd_vma sym_offset;
8195
8196 if (addr.section == SHN_UNDEF)
8197 addr.offset = fn;
8198
8199 find_symbol_for_address (filedata, aux->funtab, aux->nfuns, aux->strtab,
8200 aux->strtab_size, addr, &procname,
8201 &sym_offset);
8202
8203 print_vma (fn, PREFIX_HEX);
8204
8205 if (procname)
8206 {
8207 fputs (" <", stdout);
8208 fputs (procname, stdout);
8209
8210 if (sym_offset)
8211 printf ("+0x%lx", (unsigned long) sym_offset);
8212 fputc ('>', stdout);
8213 }
8214
8215 return procname;
8216 }
8217
8218 static void
8219 arm_free_section (struct arm_section *arm_sec)
8220 {
8221 if (arm_sec->data != NULL)
8222 free (arm_sec->data);
8223
8224 if (arm_sec->rela != NULL)
8225 free (arm_sec->rela);
8226 }
8227
8228 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8229 cached section and install SEC instead.
8230 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8231 and return its valued in * WORDP, relocating if necessary.
8232 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8233 relocation's offset in ADDR.
8234 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8235 into the string table of the symbol associated with the reloc. If no
8236 reloc was applied store -1 there.
8237 5) Return TRUE upon success, FALSE otherwise. */
8238
8239 static bfd_boolean
8240 get_unwind_section_word (Filedata * filedata,
8241 struct arm_unw_aux_info * aux,
8242 struct arm_section * arm_sec,
8243 Elf_Internal_Shdr * sec,
8244 bfd_vma word_offset,
8245 unsigned int * wordp,
8246 struct absaddr * addr,
8247 bfd_vma * sym_name)
8248 {
8249 Elf_Internal_Rela *rp;
8250 Elf_Internal_Sym *sym;
8251 const char * relname;
8252 unsigned int word;
8253 bfd_boolean wrapped;
8254
8255 if (sec == NULL || arm_sec == NULL)
8256 return FALSE;
8257
8258 addr->section = SHN_UNDEF;
8259 addr->offset = 0;
8260
8261 if (sym_name != NULL)
8262 *sym_name = (bfd_vma) -1;
8263
8264 /* If necessary, update the section cache. */
8265 if (sec != arm_sec->sec)
8266 {
8267 Elf_Internal_Shdr *relsec;
8268
8269 arm_free_section (arm_sec);
8270
8271 arm_sec->sec = sec;
8272 arm_sec->data = get_data (NULL, aux->filedata, sec->sh_offset, 1,
8273 sec->sh_size, _("unwind data"));
8274 arm_sec->rela = NULL;
8275 arm_sec->nrelas = 0;
8276
8277 for (relsec = filedata->section_headers;
8278 relsec < filedata->section_headers + filedata->file_header.e_shnum;
8279 ++relsec)
8280 {
8281 if (relsec->sh_info >= filedata->file_header.e_shnum
8282 || filedata->section_headers + relsec->sh_info != sec
8283 /* PR 15745: Check the section type as well. */
8284 || (relsec->sh_type != SHT_REL
8285 && relsec->sh_type != SHT_RELA))
8286 continue;
8287
8288 arm_sec->rel_type = relsec->sh_type;
8289 if (relsec->sh_type == SHT_REL)
8290 {
8291 if (!slurp_rel_relocs (aux->filedata, relsec->sh_offset,
8292 relsec->sh_size,
8293 & arm_sec->rela, & arm_sec->nrelas))
8294 return FALSE;
8295 }
8296 else /* relsec->sh_type == SHT_RELA */
8297 {
8298 if (!slurp_rela_relocs (aux->filedata, relsec->sh_offset,
8299 relsec->sh_size,
8300 & arm_sec->rela, & arm_sec->nrelas))
8301 return FALSE;
8302 }
8303 break;
8304 }
8305
8306 arm_sec->next_rela = arm_sec->rela;
8307 }
8308
8309 /* If there is no unwind data we can do nothing. */
8310 if (arm_sec->data == NULL)
8311 return FALSE;
8312
8313 /* If the offset is invalid then fail. */
8314 if (/* PR 21343 *//* PR 18879 */
8315 sec->sh_size < 4
8316 || word_offset > (sec->sh_size - 4)
8317 || ((bfd_signed_vma) word_offset) < 0)
8318 return FALSE;
8319
8320 /* Get the word at the required offset. */
8321 word = byte_get (arm_sec->data + word_offset, 4);
8322
8323 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8324 if (arm_sec->rela == NULL)
8325 {
8326 * wordp = word;
8327 return TRUE;
8328 }
8329
8330 /* Look through the relocs to find the one that applies to the provided offset. */
8331 wrapped = FALSE;
8332 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8333 {
8334 bfd_vma prelval, offset;
8335
8336 if (rp->r_offset > word_offset && !wrapped)
8337 {
8338 rp = arm_sec->rela;
8339 wrapped = TRUE;
8340 }
8341 if (rp->r_offset > word_offset)
8342 break;
8343
8344 if (rp->r_offset & 3)
8345 {
8346 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8347 (unsigned long) rp->r_offset);
8348 continue;
8349 }
8350
8351 if (rp->r_offset < word_offset)
8352 continue;
8353
8354 /* PR 17531: file: 027-161405-0.004 */
8355 if (aux->symtab == NULL)
8356 continue;
8357
8358 if (arm_sec->rel_type == SHT_REL)
8359 {
8360 offset = word & 0x7fffffff;
8361 if (offset & 0x40000000)
8362 offset |= ~ (bfd_vma) 0x7fffffff;
8363 }
8364 else if (arm_sec->rel_type == SHT_RELA)
8365 offset = rp->r_addend;
8366 else
8367 {
8368 error (_("Unknown section relocation type %d encountered\n"),
8369 arm_sec->rel_type);
8370 break;
8371 }
8372
8373 /* PR 17531 file: 027-1241568-0.004. */
8374 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8375 {
8376 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8377 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8378 break;
8379 }
8380
8381 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8382 offset += sym->st_value;
8383 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8384
8385 /* Check that we are processing the expected reloc type. */
8386 if (filedata->file_header.e_machine == EM_ARM)
8387 {
8388 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8389 if (relname == NULL)
8390 {
8391 warn (_("Skipping unknown ARM relocation type: %d\n"),
8392 (int) ELF32_R_TYPE (rp->r_info));
8393 continue;
8394 }
8395
8396 if (streq (relname, "R_ARM_NONE"))
8397 continue;
8398
8399 if (! streq (relname, "R_ARM_PREL31"))
8400 {
8401 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8402 continue;
8403 }
8404 }
8405 else if (filedata->file_header.e_machine == EM_TI_C6000)
8406 {
8407 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8408 if (relname == NULL)
8409 {
8410 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8411 (int) ELF32_R_TYPE (rp->r_info));
8412 continue;
8413 }
8414
8415 if (streq (relname, "R_C6000_NONE"))
8416 continue;
8417
8418 if (! streq (relname, "R_C6000_PREL31"))
8419 {
8420 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8421 continue;
8422 }
8423
8424 prelval >>= 1;
8425 }
8426 else
8427 {
8428 /* This function currently only supports ARM and TI unwinders. */
8429 warn (_("Only TI and ARM unwinders are currently supported\n"));
8430 break;
8431 }
8432
8433 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8434 addr->section = sym->st_shndx;
8435 addr->offset = offset;
8436
8437 if (sym_name)
8438 * sym_name = sym->st_name;
8439 break;
8440 }
8441
8442 *wordp = word;
8443 arm_sec->next_rela = rp;
8444
8445 return TRUE;
8446 }
8447
8448 static const char *tic6x_unwind_regnames[16] =
8449 {
8450 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8451 "A14", "A13", "A12", "A11", "A10",
8452 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8453 };
8454
8455 static void
8456 decode_tic6x_unwind_regmask (unsigned int mask)
8457 {
8458 int i;
8459
8460 for (i = 12; mask; mask >>= 1, i--)
8461 {
8462 if (mask & 1)
8463 {
8464 fputs (tic6x_unwind_regnames[i], stdout);
8465 if (mask > 1)
8466 fputs (", ", stdout);
8467 }
8468 }
8469 }
8470
8471 #define ADVANCE \
8472 if (remaining == 0 && more_words) \
8473 { \
8474 data_offset += 4; \
8475 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8476 data_offset, & word, & addr, NULL)) \
8477 return FALSE; \
8478 remaining = 4; \
8479 more_words--; \
8480 } \
8481
8482 #define GET_OP(OP) \
8483 ADVANCE; \
8484 if (remaining) \
8485 { \
8486 remaining--; \
8487 (OP) = word >> 24; \
8488 word <<= 8; \
8489 } \
8490 else \
8491 { \
8492 printf (_("[Truncated opcode]\n")); \
8493 return FALSE; \
8494 } \
8495 printf ("0x%02x ", OP)
8496
8497 static bfd_boolean
8498 decode_arm_unwind_bytecode (Filedata * filedata,
8499 struct arm_unw_aux_info * aux,
8500 unsigned int word,
8501 unsigned int remaining,
8502 unsigned int more_words,
8503 bfd_vma data_offset,
8504 Elf_Internal_Shdr * data_sec,
8505 struct arm_section * data_arm_sec)
8506 {
8507 struct absaddr addr;
8508 bfd_boolean res = TRUE;
8509
8510 /* Decode the unwinding instructions. */
8511 while (1)
8512 {
8513 unsigned int op, op2;
8514
8515 ADVANCE;
8516 if (remaining == 0)
8517 break;
8518 remaining--;
8519 op = word >> 24;
8520 word <<= 8;
8521
8522 printf (" 0x%02x ", op);
8523
8524 if ((op & 0xc0) == 0x00)
8525 {
8526 int offset = ((op & 0x3f) << 2) + 4;
8527
8528 printf (" vsp = vsp + %d", offset);
8529 }
8530 else if ((op & 0xc0) == 0x40)
8531 {
8532 int offset = ((op & 0x3f) << 2) + 4;
8533
8534 printf (" vsp = vsp - %d", offset);
8535 }
8536 else if ((op & 0xf0) == 0x80)
8537 {
8538 GET_OP (op2);
8539 if (op == 0x80 && op2 == 0)
8540 printf (_("Refuse to unwind"));
8541 else
8542 {
8543 unsigned int mask = ((op & 0x0f) << 8) | op2;
8544 bfd_boolean first = TRUE;
8545 int i;
8546
8547 printf ("pop {");
8548 for (i = 0; i < 12; i++)
8549 if (mask & (1 << i))
8550 {
8551 if (first)
8552 first = FALSE;
8553 else
8554 printf (", ");
8555 printf ("r%d", 4 + i);
8556 }
8557 printf ("}");
8558 }
8559 }
8560 else if ((op & 0xf0) == 0x90)
8561 {
8562 if (op == 0x9d || op == 0x9f)
8563 printf (_(" [Reserved]"));
8564 else
8565 printf (" vsp = r%d", op & 0x0f);
8566 }
8567 else if ((op & 0xf0) == 0xa0)
8568 {
8569 int end = 4 + (op & 0x07);
8570 bfd_boolean first = TRUE;
8571 int i;
8572
8573 printf (" pop {");
8574 for (i = 4; i <= end; i++)
8575 {
8576 if (first)
8577 first = FALSE;
8578 else
8579 printf (", ");
8580 printf ("r%d", i);
8581 }
8582 if (op & 0x08)
8583 {
8584 if (!first)
8585 printf (", ");
8586 printf ("r14");
8587 }
8588 printf ("}");
8589 }
8590 else if (op == 0xb0)
8591 printf (_(" finish"));
8592 else if (op == 0xb1)
8593 {
8594 GET_OP (op2);
8595 if (op2 == 0 || (op2 & 0xf0) != 0)
8596 printf (_("[Spare]"));
8597 else
8598 {
8599 unsigned int mask = op2 & 0x0f;
8600 bfd_boolean first = TRUE;
8601 int i;
8602
8603 printf ("pop {");
8604 for (i = 0; i < 12; i++)
8605 if (mask & (1 << i))
8606 {
8607 if (first)
8608 first = FALSE;
8609 else
8610 printf (", ");
8611 printf ("r%d", i);
8612 }
8613 printf ("}");
8614 }
8615 }
8616 else if (op == 0xb2)
8617 {
8618 unsigned char buf[9];
8619 unsigned int i, len;
8620 unsigned long offset;
8621
8622 for (i = 0; i < sizeof (buf); i++)
8623 {
8624 GET_OP (buf[i]);
8625 if ((buf[i] & 0x80) == 0)
8626 break;
8627 }
8628 if (i == sizeof (buf))
8629 {
8630 error (_("corrupt change to vsp"));
8631 res = FALSE;
8632 }
8633 else
8634 {
8635 offset = read_uleb128 (buf, &len, buf + i + 1);
8636 assert (len == i + 1);
8637 offset = offset * 4 + 0x204;
8638 printf ("vsp = vsp + %ld", offset);
8639 }
8640 }
8641 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8642 {
8643 unsigned int first, last;
8644
8645 GET_OP (op2);
8646 first = op2 >> 4;
8647 last = op2 & 0x0f;
8648 if (op == 0xc8)
8649 first = first + 16;
8650 printf ("pop {D%d", first);
8651 if (last)
8652 printf ("-D%d", first + last);
8653 printf ("}");
8654 }
8655 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8656 {
8657 unsigned int count = op & 0x07;
8658
8659 printf ("pop {D8");
8660 if (count)
8661 printf ("-D%d", 8 + count);
8662 printf ("}");
8663 }
8664 else if (op >= 0xc0 && op <= 0xc5)
8665 {
8666 unsigned int count = op & 0x07;
8667
8668 printf (" pop {wR10");
8669 if (count)
8670 printf ("-wR%d", 10 + count);
8671 printf ("}");
8672 }
8673 else if (op == 0xc6)
8674 {
8675 unsigned int first, last;
8676
8677 GET_OP (op2);
8678 first = op2 >> 4;
8679 last = op2 & 0x0f;
8680 printf ("pop {wR%d", first);
8681 if (last)
8682 printf ("-wR%d", first + last);
8683 printf ("}");
8684 }
8685 else if (op == 0xc7)
8686 {
8687 GET_OP (op2);
8688 if (op2 == 0 || (op2 & 0xf0) != 0)
8689 printf (_("[Spare]"));
8690 else
8691 {
8692 unsigned int mask = op2 & 0x0f;
8693 bfd_boolean first = TRUE;
8694 int i;
8695
8696 printf ("pop {");
8697 for (i = 0; i < 4; i++)
8698 if (mask & (1 << i))
8699 {
8700 if (first)
8701 first = FALSE;
8702 else
8703 printf (", ");
8704 printf ("wCGR%d", i);
8705 }
8706 printf ("}");
8707 }
8708 }
8709 else
8710 {
8711 printf (_(" [unsupported opcode]"));
8712 res = FALSE;
8713 }
8714
8715 printf ("\n");
8716 }
8717
8718 return res;
8719 }
8720
8721 static bfd_boolean
8722 decode_tic6x_unwind_bytecode (Filedata * filedata,
8723 struct arm_unw_aux_info * aux,
8724 unsigned int word,
8725 unsigned int remaining,
8726 unsigned int more_words,
8727 bfd_vma data_offset,
8728 Elf_Internal_Shdr * data_sec,
8729 struct arm_section * data_arm_sec)
8730 {
8731 struct absaddr addr;
8732
8733 /* Decode the unwinding instructions. */
8734 while (1)
8735 {
8736 unsigned int op, op2;
8737
8738 ADVANCE;
8739 if (remaining == 0)
8740 break;
8741 remaining--;
8742 op = word >> 24;
8743 word <<= 8;
8744
8745 printf (" 0x%02x ", op);
8746
8747 if ((op & 0xc0) == 0x00)
8748 {
8749 int offset = ((op & 0x3f) << 3) + 8;
8750 printf (" sp = sp + %d", offset);
8751 }
8752 else if ((op & 0xc0) == 0x80)
8753 {
8754 GET_OP (op2);
8755 if (op == 0x80 && op2 == 0)
8756 printf (_("Refuse to unwind"));
8757 else
8758 {
8759 unsigned int mask = ((op & 0x1f) << 8) | op2;
8760 if (op & 0x20)
8761 printf ("pop compact {");
8762 else
8763 printf ("pop {");
8764
8765 decode_tic6x_unwind_regmask (mask);
8766 printf("}");
8767 }
8768 }
8769 else if ((op & 0xf0) == 0xc0)
8770 {
8771 unsigned int reg;
8772 unsigned int nregs;
8773 unsigned int i;
8774 const char *name;
8775 struct
8776 {
8777 unsigned int offset;
8778 unsigned int reg;
8779 } regpos[16];
8780
8781 /* Scan entire instruction first so that GET_OP output is not
8782 interleaved with disassembly. */
8783 nregs = 0;
8784 for (i = 0; nregs < (op & 0xf); i++)
8785 {
8786 GET_OP (op2);
8787 reg = op2 >> 4;
8788 if (reg != 0xf)
8789 {
8790 regpos[nregs].offset = i * 2;
8791 regpos[nregs].reg = reg;
8792 nregs++;
8793 }
8794
8795 reg = op2 & 0xf;
8796 if (reg != 0xf)
8797 {
8798 regpos[nregs].offset = i * 2 + 1;
8799 regpos[nregs].reg = reg;
8800 nregs++;
8801 }
8802 }
8803
8804 printf (_("pop frame {"));
8805 reg = nregs - 1;
8806 for (i = i * 2; i > 0; i--)
8807 {
8808 if (regpos[reg].offset == i - 1)
8809 {
8810 name = tic6x_unwind_regnames[regpos[reg].reg];
8811 if (reg > 0)
8812 reg--;
8813 }
8814 else
8815 name = _("[pad]");
8816
8817 fputs (name, stdout);
8818 if (i > 1)
8819 printf (", ");
8820 }
8821
8822 printf ("}");
8823 }
8824 else if (op == 0xd0)
8825 printf (" MOV FP, SP");
8826 else if (op == 0xd1)
8827 printf (" __c6xabi_pop_rts");
8828 else if (op == 0xd2)
8829 {
8830 unsigned char buf[9];
8831 unsigned int i, len;
8832 unsigned long offset;
8833
8834 for (i = 0; i < sizeof (buf); i++)
8835 {
8836 GET_OP (buf[i]);
8837 if ((buf[i] & 0x80) == 0)
8838 break;
8839 }
8840 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8841 if (i == sizeof (buf))
8842 {
8843 warn (_("Corrupt stack pointer adjustment detected\n"));
8844 return FALSE;
8845 }
8846
8847 offset = read_uleb128 (buf, &len, buf + i + 1);
8848 assert (len == i + 1);
8849 offset = offset * 8 + 0x408;
8850 printf (_("sp = sp + %ld"), offset);
8851 }
8852 else if ((op & 0xf0) == 0xe0)
8853 {
8854 if ((op & 0x0f) == 7)
8855 printf (" RETURN");
8856 else
8857 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8858 }
8859 else
8860 {
8861 printf (_(" [unsupported opcode]"));
8862 }
8863 putchar ('\n');
8864 }
8865
8866 return TRUE;
8867 }
8868
8869 static bfd_vma
8870 arm_expand_prel31 (Filedata * filedata, bfd_vma word, bfd_vma where)
8871 {
8872 bfd_vma offset;
8873
8874 offset = word & 0x7fffffff;
8875 if (offset & 0x40000000)
8876 offset |= ~ (bfd_vma) 0x7fffffff;
8877
8878 if (filedata->file_header.e_machine == EM_TI_C6000)
8879 offset <<= 1;
8880
8881 return offset + where;
8882 }
8883
8884 static bfd_boolean
8885 decode_arm_unwind (Filedata * filedata,
8886 struct arm_unw_aux_info * aux,
8887 unsigned int word,
8888 unsigned int remaining,
8889 bfd_vma data_offset,
8890 Elf_Internal_Shdr * data_sec,
8891 struct arm_section * data_arm_sec)
8892 {
8893 int per_index;
8894 unsigned int more_words = 0;
8895 struct absaddr addr;
8896 bfd_vma sym_name = (bfd_vma) -1;
8897 bfd_boolean res = TRUE;
8898
8899 if (remaining == 0)
8900 {
8901 /* Fetch the first word.
8902 Note - when decoding an object file the address extracted
8903 here will always be 0. So we also pass in the sym_name
8904 parameter so that we can find the symbol associated with
8905 the personality routine. */
8906 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, data_offset,
8907 & word, & addr, & sym_name))
8908 return FALSE;
8909
8910 remaining = 4;
8911 }
8912
8913 if ((word & 0x80000000) == 0)
8914 {
8915 /* Expand prel31 for personality routine. */
8916 bfd_vma fn;
8917 const char *procname;
8918
8919 fn = arm_expand_prel31 (filedata, word, data_sec->sh_addr + data_offset);
8920 printf (_(" Personality routine: "));
8921 if (fn == 0
8922 && addr.section == SHN_UNDEF && addr.offset == 0
8923 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8924 {
8925 procname = aux->strtab + sym_name;
8926 print_vma (fn, PREFIX_HEX);
8927 if (procname)
8928 {
8929 fputs (" <", stdout);
8930 fputs (procname, stdout);
8931 fputc ('>', stdout);
8932 }
8933 }
8934 else
8935 procname = arm_print_vma_and_name (filedata, aux, fn, addr);
8936 fputc ('\n', stdout);
8937
8938 /* The GCC personality routines use the standard compact
8939 encoding, starting with one byte giving the number of
8940 words. */
8941 if (procname != NULL
8942 && (const_strneq (procname, "__gcc_personality_v0")
8943 || const_strneq (procname, "__gxx_personality_v0")
8944 || const_strneq (procname, "__gcj_personality_v0")
8945 || const_strneq (procname, "__gnu_objc_personality_v0")))
8946 {
8947 remaining = 0;
8948 more_words = 1;
8949 ADVANCE;
8950 if (!remaining)
8951 {
8952 printf (_(" [Truncated data]\n"));
8953 return FALSE;
8954 }
8955 more_words = word >> 24;
8956 word <<= 8;
8957 remaining--;
8958 per_index = -1;
8959 }
8960 else
8961 return TRUE;
8962 }
8963 else
8964 {
8965 /* ARM EHABI Section 6.3:
8966
8967 An exception-handling table entry for the compact model looks like:
8968
8969 31 30-28 27-24 23-0
8970 -- ----- ----- ----
8971 1 0 index Data for personalityRoutine[index] */
8972
8973 if (filedata->file_header.e_machine == EM_ARM
8974 && (word & 0x70000000))
8975 {
8976 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8977 res = FALSE;
8978 }
8979
8980 per_index = (word >> 24) & 0x7f;
8981 printf (_(" Compact model index: %d\n"), per_index);
8982 if (per_index == 0)
8983 {
8984 more_words = 0;
8985 word <<= 8;
8986 remaining--;
8987 }
8988 else if (per_index < 3)
8989 {
8990 more_words = (word >> 16) & 0xff;
8991 word <<= 16;
8992 remaining -= 2;
8993 }
8994 }
8995
8996 switch (filedata->file_header.e_machine)
8997 {
8998 case EM_ARM:
8999 if (per_index < 3)
9000 {
9001 if (! decode_arm_unwind_bytecode (filedata, aux, word, remaining, more_words,
9002 data_offset, data_sec, data_arm_sec))
9003 res = FALSE;
9004 }
9005 else
9006 {
9007 warn (_("Unknown ARM compact model index encountered\n"));
9008 printf (_(" [reserved]\n"));
9009 res = FALSE;
9010 }
9011 break;
9012
9013 case EM_TI_C6000:
9014 if (per_index < 3)
9015 {
9016 if (! decode_tic6x_unwind_bytecode (filedata, aux, word, remaining, more_words,
9017 data_offset, data_sec, data_arm_sec))
9018 res = FALSE;
9019 }
9020 else if (per_index < 5)
9021 {
9022 if (((word >> 17) & 0x7f) == 0x7f)
9023 printf (_(" Restore stack from frame pointer\n"));
9024 else
9025 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
9026 printf (_(" Registers restored: "));
9027 if (per_index == 4)
9028 printf (" (compact) ");
9029 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
9030 putchar ('\n');
9031 printf (_(" Return register: %s\n"),
9032 tic6x_unwind_regnames[word & 0xf]);
9033 }
9034 else
9035 printf (_(" [reserved (%d)]\n"), per_index);
9036 break;
9037
9038 default:
9039 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9040 filedata->file_header.e_machine);
9041 res = FALSE;
9042 }
9043
9044 /* Decode the descriptors. Not implemented. */
9045
9046 return res;
9047 }
9048
9049 static bfd_boolean
9050 dump_arm_unwind (Filedata * filedata,
9051 struct arm_unw_aux_info * aux,
9052 Elf_Internal_Shdr * exidx_sec)
9053 {
9054 struct arm_section exidx_arm_sec, extab_arm_sec;
9055 unsigned int i, exidx_len;
9056 unsigned long j, nfuns;
9057 bfd_boolean res = TRUE;
9058
9059 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
9060 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
9061 exidx_len = exidx_sec->sh_size / 8;
9062
9063 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
9064 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
9065 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
9066 aux->funtab[nfuns++] = aux->symtab[j];
9067 aux->nfuns = nfuns;
9068 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
9069
9070 for (i = 0; i < exidx_len; i++)
9071 {
9072 unsigned int exidx_fn, exidx_entry;
9073 struct absaddr fn_addr, entry_addr;
9074 bfd_vma fn;
9075
9076 fputc ('\n', stdout);
9077
9078 if (! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9079 8 * i, & exidx_fn, & fn_addr, NULL)
9080 || ! get_unwind_section_word (filedata, aux, & exidx_arm_sec, exidx_sec,
9081 8 * i + 4, & exidx_entry, & entry_addr, NULL))
9082 {
9083 free (aux->funtab);
9084 arm_free_section (& exidx_arm_sec);
9085 arm_free_section (& extab_arm_sec);
9086 return FALSE;
9087 }
9088
9089 /* ARM EHABI, Section 5:
9090 An index table entry consists of 2 words.
9091 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9092 if (exidx_fn & 0x80000000)
9093 {
9094 warn (_("corrupt index table entry: %x\n"), exidx_fn);
9095 res = FALSE;
9096 }
9097
9098 fn = arm_expand_prel31 (filedata, exidx_fn, exidx_sec->sh_addr + 8 * i);
9099
9100 arm_print_vma_and_name (filedata, aux, fn, fn_addr);
9101 fputs (": ", stdout);
9102
9103 if (exidx_entry == 1)
9104 {
9105 print_vma (exidx_entry, PREFIX_HEX);
9106 fputs (" [cantunwind]\n", stdout);
9107 }
9108 else if (exidx_entry & 0x80000000)
9109 {
9110 print_vma (exidx_entry, PREFIX_HEX);
9111 fputc ('\n', stdout);
9112 decode_arm_unwind (filedata, aux, exidx_entry, 4, 0, NULL, NULL);
9113 }
9114 else
9115 {
9116 bfd_vma table, table_offset = 0;
9117 Elf_Internal_Shdr *table_sec;
9118
9119 fputs ("@", stdout);
9120 table = arm_expand_prel31 (filedata, exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
9121 print_vma (table, PREFIX_HEX);
9122 printf ("\n");
9123
9124 /* Locate the matching .ARM.extab. */
9125 if (entry_addr.section != SHN_UNDEF
9126 && entry_addr.section < filedata->file_header.e_shnum)
9127 {
9128 table_sec = filedata->section_headers + entry_addr.section;
9129 table_offset = entry_addr.offset;
9130 /* PR 18879 */
9131 if (table_offset > table_sec->sh_size
9132 || ((bfd_signed_vma) table_offset) < 0)
9133 {
9134 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9135 (unsigned long) table_offset,
9136 printable_section_name (filedata, table_sec));
9137 res = FALSE;
9138 continue;
9139 }
9140 }
9141 else
9142 {
9143 table_sec = find_section_by_address (filedata, table);
9144 if (table_sec != NULL)
9145 table_offset = table - table_sec->sh_addr;
9146 }
9147
9148 if (table_sec == NULL)
9149 {
9150 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9151 (unsigned long) table);
9152 res = FALSE;
9153 continue;
9154 }
9155
9156 if (! decode_arm_unwind (filedata, aux, 0, 0, table_offset, table_sec,
9157 &extab_arm_sec))
9158 res = FALSE;
9159 }
9160 }
9161
9162 printf ("\n");
9163
9164 free (aux->funtab);
9165 arm_free_section (&exidx_arm_sec);
9166 arm_free_section (&extab_arm_sec);
9167
9168 return res;
9169 }
9170
9171 /* Used for both ARM and C6X unwinding tables. */
9172
9173 static bfd_boolean
9174 arm_process_unwind (Filedata * filedata)
9175 {
9176 struct arm_unw_aux_info aux;
9177 Elf_Internal_Shdr *unwsec = NULL;
9178 Elf_Internal_Shdr *strsec;
9179 Elf_Internal_Shdr *sec;
9180 unsigned long i;
9181 unsigned int sec_type;
9182 bfd_boolean res = TRUE;
9183
9184 switch (filedata->file_header.e_machine)
9185 {
9186 case EM_ARM:
9187 sec_type = SHT_ARM_EXIDX;
9188 break;
9189
9190 case EM_TI_C6000:
9191 sec_type = SHT_C6000_UNWIND;
9192 break;
9193
9194 default:
9195 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9196 filedata->file_header.e_machine);
9197 return FALSE;
9198 }
9199
9200 if (filedata->string_table == NULL)
9201 return FALSE;
9202
9203 memset (& aux, 0, sizeof (aux));
9204 aux.filedata = filedata;
9205
9206 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9207 {
9208 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < filedata->file_header.e_shnum)
9209 {
9210 aux.symtab = GET_ELF_SYMBOLS (filedata, sec, & aux.nsyms);
9211
9212 strsec = filedata->section_headers + sec->sh_link;
9213
9214 /* PR binutils/17531 file: 011-12666-0.004. */
9215 if (aux.strtab != NULL)
9216 {
9217 error (_("Multiple string tables found in file.\n"));
9218 free (aux.strtab);
9219 res = FALSE;
9220 }
9221 aux.strtab = get_data (NULL, filedata, strsec->sh_offset,
9222 1, strsec->sh_size, _("string table"));
9223 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
9224 }
9225 else if (sec->sh_type == sec_type)
9226 unwsec = sec;
9227 }
9228
9229 if (unwsec == NULL)
9230 printf (_("\nThere are no unwind sections in this file.\n"));
9231 else
9232 for (i = 0, sec = filedata->section_headers; i < filedata->file_header.e_shnum; ++i, ++sec)
9233 {
9234 if (sec->sh_type == sec_type)
9235 {
9236 unsigned long num_unwind = sec->sh_size / (2 * eh_addr_size);
9237 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9238 "contains %lu entry:\n",
9239 "\nUnwind section '%s' at offset 0x%lx "
9240 "contains %lu entries:\n",
9241 num_unwind),
9242 printable_section_name (filedata, sec),
9243 (unsigned long) sec->sh_offset,
9244 num_unwind);
9245
9246 if (! dump_arm_unwind (filedata, &aux, sec))
9247 res = FALSE;
9248 }
9249 }
9250
9251 if (aux.symtab)
9252 free (aux.symtab);
9253 if (aux.strtab)
9254 free ((char *) aux.strtab);
9255
9256 return res;
9257 }
9258
9259 static bfd_boolean
9260 process_unwind (Filedata * filedata)
9261 {
9262 struct unwind_handler
9263 {
9264 unsigned int machtype;
9265 bfd_boolean (* handler)(Filedata *);
9266 } handlers[] =
9267 {
9268 { EM_ARM, arm_process_unwind },
9269 { EM_IA_64, ia64_process_unwind },
9270 { EM_PARISC, hppa_process_unwind },
9271 { EM_TI_C6000, arm_process_unwind },
9272 { 0, NULL }
9273 };
9274 int i;
9275
9276 if (!do_unwind)
9277 return TRUE;
9278
9279 for (i = 0; handlers[i].handler != NULL; i++)
9280 if (filedata->file_header.e_machine == handlers[i].machtype)
9281 return handlers[i].handler (filedata);
9282
9283 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9284 get_machine_name (filedata->file_header.e_machine));
9285 return TRUE;
9286 }
9287
9288 static void
9289 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
9290 {
9291 switch (entry->d_tag)
9292 {
9293 case DT_MIPS_FLAGS:
9294 if (entry->d_un.d_val == 0)
9295 printf (_("NONE"));
9296 else
9297 {
9298 static const char * opts[] =
9299 {
9300 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9301 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9302 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9303 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9304 "RLD_ORDER_SAFE"
9305 };
9306 unsigned int cnt;
9307 bfd_boolean first = TRUE;
9308
9309 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9310 if (entry->d_un.d_val & (1 << cnt))
9311 {
9312 printf ("%s%s", first ? "" : " ", opts[cnt]);
9313 first = FALSE;
9314 }
9315 }
9316 break;
9317
9318 case DT_MIPS_IVERSION:
9319 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9320 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
9321 else
9322 {
9323 char buf[40];
9324 sprintf_vma (buf, entry->d_un.d_ptr);
9325 /* Note: coded this way so that there is a single string for translation. */
9326 printf (_("<corrupt: %s>"), buf);
9327 }
9328 break;
9329
9330 case DT_MIPS_TIME_STAMP:
9331 {
9332 char timebuf[128];
9333 struct tm * tmp;
9334 time_t atime = entry->d_un.d_val;
9335
9336 tmp = gmtime (&atime);
9337 /* PR 17531: file: 6accc532. */
9338 if (tmp == NULL)
9339 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9340 else
9341 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9342 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9343 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9344 printf (_("Time Stamp: %s"), timebuf);
9345 }
9346 break;
9347
9348 case DT_MIPS_RLD_VERSION:
9349 case DT_MIPS_LOCAL_GOTNO:
9350 case DT_MIPS_CONFLICTNO:
9351 case DT_MIPS_LIBLISTNO:
9352 case DT_MIPS_SYMTABNO:
9353 case DT_MIPS_UNREFEXTNO:
9354 case DT_MIPS_HIPAGENO:
9355 case DT_MIPS_DELTA_CLASS_NO:
9356 case DT_MIPS_DELTA_INSTANCE_NO:
9357 case DT_MIPS_DELTA_RELOC_NO:
9358 case DT_MIPS_DELTA_SYM_NO:
9359 case DT_MIPS_DELTA_CLASSSYM_NO:
9360 case DT_MIPS_COMPACT_SIZE:
9361 print_vma (entry->d_un.d_val, DEC);
9362 break;
9363
9364 default:
9365 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9366 }
9367 putchar ('\n');
9368 }
9369
9370 static void
9371 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9372 {
9373 switch (entry->d_tag)
9374 {
9375 case DT_HP_DLD_FLAGS:
9376 {
9377 static struct
9378 {
9379 long int bit;
9380 const char * str;
9381 }
9382 flags[] =
9383 {
9384 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9385 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9386 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9387 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9388 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9389 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9390 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9391 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9392 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9393 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9394 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9395 { DT_HP_GST, "HP_GST" },
9396 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9397 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9398 { DT_HP_NODELETE, "HP_NODELETE" },
9399 { DT_HP_GROUP, "HP_GROUP" },
9400 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9401 };
9402 bfd_boolean first = TRUE;
9403 size_t cnt;
9404 bfd_vma val = entry->d_un.d_val;
9405
9406 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9407 if (val & flags[cnt].bit)
9408 {
9409 if (! first)
9410 putchar (' ');
9411 fputs (flags[cnt].str, stdout);
9412 first = FALSE;
9413 val ^= flags[cnt].bit;
9414 }
9415
9416 if (val != 0 || first)
9417 {
9418 if (! first)
9419 putchar (' ');
9420 print_vma (val, HEX);
9421 }
9422 }
9423 break;
9424
9425 default:
9426 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9427 break;
9428 }
9429 putchar ('\n');
9430 }
9431
9432 #ifdef BFD64
9433
9434 /* VMS vs Unix time offset and factor. */
9435
9436 #define VMS_EPOCH_OFFSET 35067168000000000LL
9437 #define VMS_GRANULARITY_FACTOR 10000000
9438
9439 /* Display a VMS time in a human readable format. */
9440
9441 static void
9442 print_vms_time (bfd_int64_t vmstime)
9443 {
9444 struct tm *tm;
9445 time_t unxtime;
9446
9447 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9448 tm = gmtime (&unxtime);
9449 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9450 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9451 tm->tm_hour, tm->tm_min, tm->tm_sec);
9452 }
9453 #endif /* BFD64 */
9454
9455 static void
9456 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9457 {
9458 switch (entry->d_tag)
9459 {
9460 case DT_IA_64_PLT_RESERVE:
9461 /* First 3 slots reserved. */
9462 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9463 printf (" -- ");
9464 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9465 break;
9466
9467 case DT_IA_64_VMS_LINKTIME:
9468 #ifdef BFD64
9469 print_vms_time (entry->d_un.d_val);
9470 #endif
9471 break;
9472
9473 case DT_IA_64_VMS_LNKFLAGS:
9474 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9475 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9476 printf (" CALL_DEBUG");
9477 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9478 printf (" NOP0BUFS");
9479 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9480 printf (" P0IMAGE");
9481 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9482 printf (" MKTHREADS");
9483 if (entry->d_un.d_val & VMS_LF_UPCALLS)
9484 printf (" UPCALLS");
9485 if (entry->d_un.d_val & VMS_LF_IMGSTA)
9486 printf (" IMGSTA");
9487 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9488 printf (" INITIALIZE");
9489 if (entry->d_un.d_val & VMS_LF_MAIN)
9490 printf (" MAIN");
9491 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9492 printf (" EXE_INIT");
9493 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9494 printf (" TBK_IN_IMG");
9495 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9496 printf (" DBG_IN_IMG");
9497 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9498 printf (" TBK_IN_DSF");
9499 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9500 printf (" DBG_IN_DSF");
9501 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9502 printf (" SIGNATURES");
9503 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9504 printf (" REL_SEG_OFF");
9505 break;
9506
9507 default:
9508 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9509 break;
9510 }
9511 putchar ('\n');
9512 }
9513
9514 static bfd_boolean
9515 get_32bit_dynamic_section (Filedata * filedata)
9516 {
9517 Elf32_External_Dyn * edyn;
9518 Elf32_External_Dyn * ext;
9519 Elf_Internal_Dyn * entry;
9520
9521 edyn = (Elf32_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9522 dynamic_size, _("dynamic section"));
9523 if (!edyn)
9524 return FALSE;
9525
9526 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9527 might not have the luxury of section headers. Look for the DT_NULL
9528 terminator to determine the number of entries. */
9529 for (ext = edyn, dynamic_nent = 0;
9530 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9531 ext++)
9532 {
9533 dynamic_nent++;
9534 if (BYTE_GET (ext->d_tag) == DT_NULL)
9535 break;
9536 }
9537
9538 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9539 sizeof (* entry));
9540 if (dynamic_section == NULL)
9541 {
9542 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9543 (unsigned long) dynamic_nent);
9544 free (edyn);
9545 return FALSE;
9546 }
9547
9548 for (ext = edyn, entry = dynamic_section;
9549 entry < dynamic_section + dynamic_nent;
9550 ext++, entry++)
9551 {
9552 entry->d_tag = BYTE_GET (ext->d_tag);
9553 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9554 }
9555
9556 free (edyn);
9557
9558 return TRUE;
9559 }
9560
9561 static bfd_boolean
9562 get_64bit_dynamic_section (Filedata * filedata)
9563 {
9564 Elf64_External_Dyn * edyn;
9565 Elf64_External_Dyn * ext;
9566 Elf_Internal_Dyn * entry;
9567
9568 /* Read in the data. */
9569 edyn = (Elf64_External_Dyn *) get_data (NULL, filedata, dynamic_addr, 1,
9570 dynamic_size, _("dynamic section"));
9571 if (!edyn)
9572 return FALSE;
9573
9574 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9575 might not have the luxury of section headers. Look for the DT_NULL
9576 terminator to determine the number of entries. */
9577 for (ext = edyn, dynamic_nent = 0;
9578 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9579 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9580 ext++)
9581 {
9582 dynamic_nent++;
9583 if (BYTE_GET (ext->d_tag) == DT_NULL)
9584 break;
9585 }
9586
9587 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9588 sizeof (* entry));
9589 if (dynamic_section == NULL)
9590 {
9591 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9592 (unsigned long) dynamic_nent);
9593 free (edyn);
9594 return FALSE;
9595 }
9596
9597 /* Convert from external to internal formats. */
9598 for (ext = edyn, entry = dynamic_section;
9599 entry < dynamic_section + dynamic_nent;
9600 ext++, entry++)
9601 {
9602 entry->d_tag = BYTE_GET (ext->d_tag);
9603 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9604 }
9605
9606 free (edyn);
9607
9608 return TRUE;
9609 }
9610
9611 static void
9612 print_dynamic_flags (bfd_vma flags)
9613 {
9614 bfd_boolean first = TRUE;
9615
9616 while (flags)
9617 {
9618 bfd_vma flag;
9619
9620 flag = flags & - flags;
9621 flags &= ~ flag;
9622
9623 if (first)
9624 first = FALSE;
9625 else
9626 putc (' ', stdout);
9627
9628 switch (flag)
9629 {
9630 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
9631 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
9632 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
9633 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
9634 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
9635 default: fputs (_("unknown"), stdout); break;
9636 }
9637 }
9638 puts ("");
9639 }
9640
9641 /* Parse and display the contents of the dynamic section. */
9642
9643 static bfd_boolean
9644 process_dynamic_section (Filedata * filedata)
9645 {
9646 Elf_Internal_Dyn * entry;
9647
9648 if (dynamic_size == 0)
9649 {
9650 if (do_dynamic)
9651 printf (_("\nThere is no dynamic section in this file.\n"));
9652
9653 return TRUE;
9654 }
9655
9656 if (is_32bit_elf)
9657 {
9658 if (! get_32bit_dynamic_section (filedata))
9659 return FALSE;
9660 }
9661 else
9662 {
9663 if (! get_64bit_dynamic_section (filedata))
9664 return FALSE;
9665 }
9666
9667 /* Find the appropriate symbol table. */
9668 if (dynamic_symbols == NULL)
9669 {
9670 for (entry = dynamic_section;
9671 entry < dynamic_section + dynamic_nent;
9672 ++entry)
9673 {
9674 Elf_Internal_Shdr section;
9675
9676 if (entry->d_tag != DT_SYMTAB)
9677 continue;
9678
9679 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9680
9681 /* Since we do not know how big the symbol table is,
9682 we default to reading in the entire file (!) and
9683 processing that. This is overkill, I know, but it
9684 should work. */
9685 section.sh_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9686 if ((bfd_size_type) section.sh_offset > filedata->file_size)
9687 {
9688 /* See PR 21379 for a reproducer. */
9689 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section.sh_offset);
9690 return FALSE;
9691 }
9692
9693 if (archive_file_offset != 0)
9694 section.sh_size = archive_file_size - section.sh_offset;
9695 else
9696 section.sh_size = filedata->file_size - section.sh_offset;
9697
9698 if (is_32bit_elf)
9699 section.sh_entsize = sizeof (Elf32_External_Sym);
9700 else
9701 section.sh_entsize = sizeof (Elf64_External_Sym);
9702 section.sh_name = filedata->string_table_length;
9703
9704 if (dynamic_symbols != NULL)
9705 {
9706 error (_("Multiple dynamic symbol table sections found\n"));
9707 free (dynamic_symbols);
9708 }
9709 dynamic_symbols = GET_ELF_SYMBOLS (filedata, &section, & num_dynamic_syms);
9710 if (num_dynamic_syms < 1)
9711 {
9712 error (_("Unable to determine the number of symbols to load\n"));
9713 continue;
9714 }
9715 }
9716 }
9717
9718 /* Similarly find a string table. */
9719 if (dynamic_strings == NULL)
9720 {
9721 for (entry = dynamic_section;
9722 entry < dynamic_section + dynamic_nent;
9723 ++entry)
9724 {
9725 unsigned long offset;
9726 long str_tab_len;
9727
9728 if (entry->d_tag != DT_STRTAB)
9729 continue;
9730
9731 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9732
9733 /* Since we do not know how big the string table is,
9734 we default to reading in the entire file (!) and
9735 processing that. This is overkill, I know, but it
9736 should work. */
9737
9738 offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
9739
9740 if (archive_file_offset != 0)
9741 str_tab_len = archive_file_size - offset;
9742 else
9743 str_tab_len = filedata->file_size - offset;
9744
9745 if (str_tab_len < 1)
9746 {
9747 error
9748 (_("Unable to determine the length of the dynamic string table\n"));
9749 continue;
9750 }
9751
9752 if (dynamic_strings != NULL)
9753 {
9754 error (_("Multiple dynamic string tables found\n"));
9755 free (dynamic_strings);
9756 }
9757
9758 dynamic_strings = (char *) get_data (NULL, filedata, offset, 1,
9759 str_tab_len,
9760 _("dynamic string table"));
9761 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9762 }
9763 }
9764
9765 /* And find the syminfo section if available. */
9766 if (dynamic_syminfo == NULL)
9767 {
9768 unsigned long syminsz = 0;
9769
9770 for (entry = dynamic_section;
9771 entry < dynamic_section + dynamic_nent;
9772 ++entry)
9773 {
9774 if (entry->d_tag == DT_SYMINENT)
9775 {
9776 /* Note: these braces are necessary to avoid a syntax
9777 error from the SunOS4 C compiler. */
9778 /* PR binutils/17531: A corrupt file can trigger this test.
9779 So do not use an assert, instead generate an error message. */
9780 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9781 error (_("Bad value (%d) for SYMINENT entry\n"),
9782 (int) entry->d_un.d_val);
9783 }
9784 else if (entry->d_tag == DT_SYMINSZ)
9785 syminsz = entry->d_un.d_val;
9786 else if (entry->d_tag == DT_SYMINFO)
9787 dynamic_syminfo_offset = offset_from_vma (filedata, entry->d_un.d_val,
9788 syminsz);
9789 }
9790
9791 if (dynamic_syminfo_offset != 0 && syminsz != 0)
9792 {
9793 Elf_External_Syminfo * extsyminfo;
9794 Elf_External_Syminfo * extsym;
9795 Elf_Internal_Syminfo * syminfo;
9796
9797 /* There is a syminfo section. Read the data. */
9798 extsyminfo = (Elf_External_Syminfo *)
9799 get_data (NULL, filedata, dynamic_syminfo_offset, 1, syminsz,
9800 _("symbol information"));
9801 if (!extsyminfo)
9802 return FALSE;
9803
9804 if (dynamic_syminfo != NULL)
9805 {
9806 error (_("Multiple dynamic symbol information sections found\n"));
9807 free (dynamic_syminfo);
9808 }
9809 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
9810 if (dynamic_syminfo == NULL)
9811 {
9812 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9813 (unsigned long) syminsz);
9814 return FALSE;
9815 }
9816
9817 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
9818 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9819 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9820 ++syminfo, ++extsym)
9821 {
9822 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9823 syminfo->si_flags = BYTE_GET (extsym->si_flags);
9824 }
9825
9826 free (extsyminfo);
9827 }
9828 }
9829
9830 if (do_dynamic && dynamic_addr)
9831 printf (ngettext ("\nDynamic section at offset 0x%lx "
9832 "contains %lu entry:\n",
9833 "\nDynamic section at offset 0x%lx "
9834 "contains %lu entries:\n",
9835 dynamic_nent),
9836 dynamic_addr, (unsigned long) dynamic_nent);
9837 if (do_dynamic)
9838 printf (_(" Tag Type Name/Value\n"));
9839
9840 for (entry = dynamic_section;
9841 entry < dynamic_section + dynamic_nent;
9842 entry++)
9843 {
9844 if (do_dynamic)
9845 {
9846 const char * dtype;
9847
9848 putchar (' ');
9849 print_vma (entry->d_tag, FULL_HEX);
9850 dtype = get_dynamic_type (filedata, entry->d_tag);
9851 printf (" (%s)%*s", dtype,
9852 ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
9853 }
9854
9855 switch (entry->d_tag)
9856 {
9857 case DT_FLAGS:
9858 if (do_dynamic)
9859 print_dynamic_flags (entry->d_un.d_val);
9860 break;
9861
9862 case DT_AUXILIARY:
9863 case DT_FILTER:
9864 case DT_CONFIG:
9865 case DT_DEPAUDIT:
9866 case DT_AUDIT:
9867 if (do_dynamic)
9868 {
9869 switch (entry->d_tag)
9870 {
9871 case DT_AUXILIARY:
9872 printf (_("Auxiliary library"));
9873 break;
9874
9875 case DT_FILTER:
9876 printf (_("Filter library"));
9877 break;
9878
9879 case DT_CONFIG:
9880 printf (_("Configuration file"));
9881 break;
9882
9883 case DT_DEPAUDIT:
9884 printf (_("Dependency audit library"));
9885 break;
9886
9887 case DT_AUDIT:
9888 printf (_("Audit library"));
9889 break;
9890 }
9891
9892 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9893 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
9894 else
9895 {
9896 printf (": ");
9897 print_vma (entry->d_un.d_val, PREFIX_HEX);
9898 putchar ('\n');
9899 }
9900 }
9901 break;
9902
9903 case DT_FEATURE:
9904 if (do_dynamic)
9905 {
9906 printf (_("Flags:"));
9907
9908 if (entry->d_un.d_val == 0)
9909 printf (_(" None\n"));
9910 else
9911 {
9912 unsigned long int val = entry->d_un.d_val;
9913
9914 if (val & DTF_1_PARINIT)
9915 {
9916 printf (" PARINIT");
9917 val ^= DTF_1_PARINIT;
9918 }
9919 if (val & DTF_1_CONFEXP)
9920 {
9921 printf (" CONFEXP");
9922 val ^= DTF_1_CONFEXP;
9923 }
9924 if (val != 0)
9925 printf (" %lx", val);
9926 puts ("");
9927 }
9928 }
9929 break;
9930
9931 case DT_POSFLAG_1:
9932 if (do_dynamic)
9933 {
9934 printf (_("Flags:"));
9935
9936 if (entry->d_un.d_val == 0)
9937 printf (_(" None\n"));
9938 else
9939 {
9940 unsigned long int val = entry->d_un.d_val;
9941
9942 if (val & DF_P1_LAZYLOAD)
9943 {
9944 printf (" LAZYLOAD");
9945 val ^= DF_P1_LAZYLOAD;
9946 }
9947 if (val & DF_P1_GROUPPERM)
9948 {
9949 printf (" GROUPPERM");
9950 val ^= DF_P1_GROUPPERM;
9951 }
9952 if (val != 0)
9953 printf (" %lx", val);
9954 puts ("");
9955 }
9956 }
9957 break;
9958
9959 case DT_FLAGS_1:
9960 if (do_dynamic)
9961 {
9962 printf (_("Flags:"));
9963 if (entry->d_un.d_val == 0)
9964 printf (_(" None\n"));
9965 else
9966 {
9967 unsigned long int val = entry->d_un.d_val;
9968
9969 if (val & DF_1_NOW)
9970 {
9971 printf (" NOW");
9972 val ^= DF_1_NOW;
9973 }
9974 if (val & DF_1_GLOBAL)
9975 {
9976 printf (" GLOBAL");
9977 val ^= DF_1_GLOBAL;
9978 }
9979 if (val & DF_1_GROUP)
9980 {
9981 printf (" GROUP");
9982 val ^= DF_1_GROUP;
9983 }
9984 if (val & DF_1_NODELETE)
9985 {
9986 printf (" NODELETE");
9987 val ^= DF_1_NODELETE;
9988 }
9989 if (val & DF_1_LOADFLTR)
9990 {
9991 printf (" LOADFLTR");
9992 val ^= DF_1_LOADFLTR;
9993 }
9994 if (val & DF_1_INITFIRST)
9995 {
9996 printf (" INITFIRST");
9997 val ^= DF_1_INITFIRST;
9998 }
9999 if (val & DF_1_NOOPEN)
10000 {
10001 printf (" NOOPEN");
10002 val ^= DF_1_NOOPEN;
10003 }
10004 if (val & DF_1_ORIGIN)
10005 {
10006 printf (" ORIGIN");
10007 val ^= DF_1_ORIGIN;
10008 }
10009 if (val & DF_1_DIRECT)
10010 {
10011 printf (" DIRECT");
10012 val ^= DF_1_DIRECT;
10013 }
10014 if (val & DF_1_TRANS)
10015 {
10016 printf (" TRANS");
10017 val ^= DF_1_TRANS;
10018 }
10019 if (val & DF_1_INTERPOSE)
10020 {
10021 printf (" INTERPOSE");
10022 val ^= DF_1_INTERPOSE;
10023 }
10024 if (val & DF_1_NODEFLIB)
10025 {
10026 printf (" NODEFLIB");
10027 val ^= DF_1_NODEFLIB;
10028 }
10029 if (val & DF_1_NODUMP)
10030 {
10031 printf (" NODUMP");
10032 val ^= DF_1_NODUMP;
10033 }
10034 if (val & DF_1_CONFALT)
10035 {
10036 printf (" CONFALT");
10037 val ^= DF_1_CONFALT;
10038 }
10039 if (val & DF_1_ENDFILTEE)
10040 {
10041 printf (" ENDFILTEE");
10042 val ^= DF_1_ENDFILTEE;
10043 }
10044 if (val & DF_1_DISPRELDNE)
10045 {
10046 printf (" DISPRELDNE");
10047 val ^= DF_1_DISPRELDNE;
10048 }
10049 if (val & DF_1_DISPRELPND)
10050 {
10051 printf (" DISPRELPND");
10052 val ^= DF_1_DISPRELPND;
10053 }
10054 if (val & DF_1_NODIRECT)
10055 {
10056 printf (" NODIRECT");
10057 val ^= DF_1_NODIRECT;
10058 }
10059 if (val & DF_1_IGNMULDEF)
10060 {
10061 printf (" IGNMULDEF");
10062 val ^= DF_1_IGNMULDEF;
10063 }
10064 if (val & DF_1_NOKSYMS)
10065 {
10066 printf (" NOKSYMS");
10067 val ^= DF_1_NOKSYMS;
10068 }
10069 if (val & DF_1_NOHDR)
10070 {
10071 printf (" NOHDR");
10072 val ^= DF_1_NOHDR;
10073 }
10074 if (val & DF_1_EDITED)
10075 {
10076 printf (" EDITED");
10077 val ^= DF_1_EDITED;
10078 }
10079 if (val & DF_1_NORELOC)
10080 {
10081 printf (" NORELOC");
10082 val ^= DF_1_NORELOC;
10083 }
10084 if (val & DF_1_SYMINTPOSE)
10085 {
10086 printf (" SYMINTPOSE");
10087 val ^= DF_1_SYMINTPOSE;
10088 }
10089 if (val & DF_1_GLOBAUDIT)
10090 {
10091 printf (" GLOBAUDIT");
10092 val ^= DF_1_GLOBAUDIT;
10093 }
10094 if (val & DF_1_SINGLETON)
10095 {
10096 printf (" SINGLETON");
10097 val ^= DF_1_SINGLETON;
10098 }
10099 if (val & DF_1_STUB)
10100 {
10101 printf (" STUB");
10102 val ^= DF_1_STUB;
10103 }
10104 if (val & DF_1_PIE)
10105 {
10106 printf (" PIE");
10107 val ^= DF_1_PIE;
10108 }
10109 if (val & DF_1_KMOD)
10110 {
10111 printf (" KMOD");
10112 val ^= DF_1_KMOD;
10113 }
10114 if (val & DF_1_WEAKFILTER)
10115 {
10116 printf (" WEAKFILTER");
10117 val ^= DF_1_WEAKFILTER;
10118 }
10119 if (val & DF_1_NOCOMMON)
10120 {
10121 printf (" NOCOMMON");
10122 val ^= DF_1_NOCOMMON;
10123 }
10124 if (val != 0)
10125 printf (" %lx", val);
10126 puts ("");
10127 }
10128 }
10129 break;
10130
10131 case DT_PLTREL:
10132 dynamic_info[entry->d_tag] = entry->d_un.d_val;
10133 if (do_dynamic)
10134 puts (get_dynamic_type (filedata, entry->d_un.d_val));
10135 break;
10136
10137 case DT_NULL :
10138 case DT_NEEDED :
10139 case DT_PLTGOT :
10140 case DT_HASH :
10141 case DT_STRTAB :
10142 case DT_SYMTAB :
10143 case DT_RELA :
10144 case DT_INIT :
10145 case DT_FINI :
10146 case DT_SONAME :
10147 case DT_RPATH :
10148 case DT_SYMBOLIC:
10149 case DT_REL :
10150 case DT_DEBUG :
10151 case DT_TEXTREL :
10152 case DT_JMPREL :
10153 case DT_RUNPATH :
10154 dynamic_info[entry->d_tag] = entry->d_un.d_val;
10155
10156 if (do_dynamic)
10157 {
10158 char * name;
10159
10160 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
10161 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10162 else
10163 name = NULL;
10164
10165 if (name)
10166 {
10167 switch (entry->d_tag)
10168 {
10169 case DT_NEEDED:
10170 printf (_("Shared library: [%s]"), name);
10171
10172 if (streq (name, program_interpreter))
10173 printf (_(" program interpreter"));
10174 break;
10175
10176 case DT_SONAME:
10177 printf (_("Library soname: [%s]"), name);
10178 break;
10179
10180 case DT_RPATH:
10181 printf (_("Library rpath: [%s]"), name);
10182 break;
10183
10184 case DT_RUNPATH:
10185 printf (_("Library runpath: [%s]"), name);
10186 break;
10187
10188 default:
10189 print_vma (entry->d_un.d_val, PREFIX_HEX);
10190 break;
10191 }
10192 }
10193 else
10194 print_vma (entry->d_un.d_val, PREFIX_HEX);
10195
10196 putchar ('\n');
10197 }
10198 break;
10199
10200 case DT_PLTRELSZ:
10201 case DT_RELASZ :
10202 case DT_STRSZ :
10203 case DT_RELSZ :
10204 case DT_RELAENT :
10205 case DT_SYMENT :
10206 case DT_RELENT :
10207 dynamic_info[entry->d_tag] = entry->d_un.d_val;
10208 /* Fall through. */
10209 case DT_PLTPADSZ:
10210 case DT_MOVEENT :
10211 case DT_MOVESZ :
10212 case DT_INIT_ARRAYSZ:
10213 case DT_FINI_ARRAYSZ:
10214 case DT_GNU_CONFLICTSZ:
10215 case DT_GNU_LIBLISTSZ:
10216 if (do_dynamic)
10217 {
10218 print_vma (entry->d_un.d_val, UNSIGNED);
10219 printf (_(" (bytes)\n"));
10220 }
10221 break;
10222
10223 case DT_VERDEFNUM:
10224 case DT_VERNEEDNUM:
10225 case DT_RELACOUNT:
10226 case DT_RELCOUNT:
10227 if (do_dynamic)
10228 {
10229 print_vma (entry->d_un.d_val, UNSIGNED);
10230 putchar ('\n');
10231 }
10232 break;
10233
10234 case DT_SYMINSZ:
10235 case DT_SYMINENT:
10236 case DT_SYMINFO:
10237 case DT_USED:
10238 case DT_INIT_ARRAY:
10239 case DT_FINI_ARRAY:
10240 if (do_dynamic)
10241 {
10242 if (entry->d_tag == DT_USED
10243 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
10244 {
10245 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
10246
10247 if (*name)
10248 {
10249 printf (_("Not needed object: [%s]\n"), name);
10250 break;
10251 }
10252 }
10253
10254 print_vma (entry->d_un.d_val, PREFIX_HEX);
10255 putchar ('\n');
10256 }
10257 break;
10258
10259 case DT_BIND_NOW:
10260 /* The value of this entry is ignored. */
10261 if (do_dynamic)
10262 putchar ('\n');
10263 break;
10264
10265 case DT_GNU_PRELINKED:
10266 if (do_dynamic)
10267 {
10268 struct tm * tmp;
10269 time_t atime = entry->d_un.d_val;
10270
10271 tmp = gmtime (&atime);
10272 /* PR 17533 file: 041-1244816-0.004. */
10273 if (tmp == NULL)
10274 printf (_("<corrupt time val: %lx"),
10275 (unsigned long) atime);
10276 else
10277 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10278 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10279 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10280
10281 }
10282 break;
10283
10284 case DT_GNU_HASH:
10285 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
10286 if (do_dynamic)
10287 {
10288 print_vma (entry->d_un.d_val, PREFIX_HEX);
10289 putchar ('\n');
10290 }
10291 break;
10292
10293 default:
10294 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
10295 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
10296 entry->d_un.d_val;
10297
10298 if (do_dynamic)
10299 {
10300 switch (filedata->file_header.e_machine)
10301 {
10302 case EM_MIPS:
10303 case EM_MIPS_RS3_LE:
10304 dynamic_section_mips_val (entry);
10305 break;
10306 case EM_PARISC:
10307 dynamic_section_parisc_val (entry);
10308 break;
10309 case EM_IA_64:
10310 dynamic_section_ia64_val (entry);
10311 break;
10312 default:
10313 print_vma (entry->d_un.d_val, PREFIX_HEX);
10314 putchar ('\n');
10315 }
10316 }
10317 break;
10318 }
10319 }
10320
10321 return TRUE;
10322 }
10323
10324 static char *
10325 get_ver_flags (unsigned int flags)
10326 {
10327 static char buff[128];
10328
10329 buff[0] = 0;
10330
10331 if (flags == 0)
10332 return _("none");
10333
10334 if (flags & VER_FLG_BASE)
10335 strcat (buff, "BASE");
10336
10337 if (flags & VER_FLG_WEAK)
10338 {
10339 if (flags & VER_FLG_BASE)
10340 strcat (buff, " | ");
10341
10342 strcat (buff, "WEAK");
10343 }
10344
10345 if (flags & VER_FLG_INFO)
10346 {
10347 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10348 strcat (buff, " | ");
10349
10350 strcat (buff, "INFO");
10351 }
10352
10353 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10354 {
10355 if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10356 strcat (buff, " | ");
10357
10358 strcat (buff, _("<unknown>"));
10359 }
10360
10361 return buff;
10362 }
10363
10364 /* Display the contents of the version sections. */
10365
10366 static bfd_boolean
10367 process_version_sections (Filedata * filedata)
10368 {
10369 Elf_Internal_Shdr * section;
10370 unsigned i;
10371 bfd_boolean found = FALSE;
10372
10373 if (! do_version)
10374 return TRUE;
10375
10376 for (i = 0, section = filedata->section_headers;
10377 i < filedata->file_header.e_shnum;
10378 i++, section++)
10379 {
10380 switch (section->sh_type)
10381 {
10382 case SHT_GNU_verdef:
10383 {
10384 Elf_External_Verdef * edefs;
10385 unsigned long idx;
10386 unsigned long cnt;
10387 char * endbuf;
10388
10389 found = TRUE;
10390
10391 printf (ngettext ("\nVersion definition section '%s' "
10392 "contains %u entry:\n",
10393 "\nVersion definition section '%s' "
10394 "contains %u entries:\n",
10395 section->sh_info),
10396 printable_section_name (filedata, section),
10397 section->sh_info);
10398
10399 printf (_(" Addr: 0x"));
10400 printf_vma (section->sh_addr);
10401 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10402 (unsigned long) section->sh_offset, section->sh_link,
10403 printable_section_name_from_index (filedata, section->sh_link));
10404
10405 edefs = (Elf_External_Verdef *)
10406 get_data (NULL, filedata, section->sh_offset, 1,section->sh_size,
10407 _("version definition section"));
10408 if (!edefs)
10409 break;
10410 endbuf = (char *) edefs + section->sh_size;
10411
10412 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10413 {
10414 char * vstart;
10415 Elf_External_Verdef * edef;
10416 Elf_Internal_Verdef ent;
10417 Elf_External_Verdaux * eaux;
10418 Elf_Internal_Verdaux aux;
10419 unsigned long isum;
10420 int j;
10421
10422 vstart = ((char *) edefs) + idx;
10423 if (vstart + sizeof (*edef) > endbuf)
10424 break;
10425
10426 edef = (Elf_External_Verdef *) vstart;
10427
10428 ent.vd_version = BYTE_GET (edef->vd_version);
10429 ent.vd_flags = BYTE_GET (edef->vd_flags);
10430 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
10431 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
10432 ent.vd_hash = BYTE_GET (edef->vd_hash);
10433 ent.vd_aux = BYTE_GET (edef->vd_aux);
10434 ent.vd_next = BYTE_GET (edef->vd_next);
10435
10436 printf (_(" %#06lx: Rev: %d Flags: %s"),
10437 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10438
10439 printf (_(" Index: %d Cnt: %d "),
10440 ent.vd_ndx, ent.vd_cnt);
10441
10442 /* Check for overflow. */
10443 if (ent.vd_aux > (size_t) (endbuf - vstart))
10444 break;
10445
10446 vstart += ent.vd_aux;
10447
10448 if (vstart + sizeof (*eaux) > endbuf)
10449 break;
10450 eaux = (Elf_External_Verdaux *) vstart;
10451
10452 aux.vda_name = BYTE_GET (eaux->vda_name);
10453 aux.vda_next = BYTE_GET (eaux->vda_next);
10454
10455 if (VALID_DYNAMIC_NAME (aux.vda_name))
10456 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
10457 else
10458 printf (_("Name index: %ld\n"), aux.vda_name);
10459
10460 isum = idx + ent.vd_aux;
10461
10462 for (j = 1; j < ent.vd_cnt; j++)
10463 {
10464 if (aux.vda_next < sizeof (*eaux)
10465 && !(j == ent.vd_cnt - 1 && aux.vda_next == 0))
10466 {
10467 warn (_("Invalid vda_next field of %lx\n"),
10468 aux.vda_next);
10469 j = ent.vd_cnt;
10470 break;
10471 }
10472 /* Check for overflow. */
10473 if (aux.vda_next > (size_t) (endbuf - vstart))
10474 break;
10475
10476 isum += aux.vda_next;
10477 vstart += aux.vda_next;
10478
10479 if (vstart + sizeof (*eaux) > endbuf)
10480 break;
10481 eaux = (Elf_External_Verdaux *) vstart;
10482
10483 aux.vda_name = BYTE_GET (eaux->vda_name);
10484 aux.vda_next = BYTE_GET (eaux->vda_next);
10485
10486 if (VALID_DYNAMIC_NAME (aux.vda_name))
10487 printf (_(" %#06lx: Parent %d: %s\n"),
10488 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
10489 else
10490 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10491 isum, j, aux.vda_name);
10492 }
10493
10494 if (j < ent.vd_cnt)
10495 printf (_(" Version def aux past end of section\n"));
10496
10497 /* PR 17531:
10498 file: id:000001,src:000172+005151,op:splice,rep:2. */
10499 if (ent.vd_next < sizeof (*edef)
10500 && !(cnt == section->sh_info - 1 && ent.vd_next == 0))
10501 {
10502 warn (_("Invalid vd_next field of %lx\n"), ent.vd_next);
10503 cnt = section->sh_info;
10504 break;
10505 }
10506 if (ent.vd_next > (size_t) (endbuf - ((char *) edefs + idx)))
10507 break;
10508
10509 idx += ent.vd_next;
10510 }
10511
10512 if (cnt < section->sh_info)
10513 printf (_(" Version definition past end of section\n"));
10514
10515 free (edefs);
10516 }
10517 break;
10518
10519 case SHT_GNU_verneed:
10520 {
10521 Elf_External_Verneed * eneed;
10522 unsigned long idx;
10523 unsigned long cnt;
10524 char * endbuf;
10525
10526 found = TRUE;
10527
10528 printf (ngettext ("\nVersion needs section '%s' "
10529 "contains %u entry:\n",
10530 "\nVersion needs section '%s' "
10531 "contains %u entries:\n",
10532 section->sh_info),
10533 printable_section_name (filedata, section), section->sh_info);
10534
10535 printf (_(" Addr: 0x"));
10536 printf_vma (section->sh_addr);
10537 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10538 (unsigned long) section->sh_offset, section->sh_link,
10539 printable_section_name_from_index (filedata, section->sh_link));
10540
10541 eneed = (Elf_External_Verneed *) get_data (NULL, filedata,
10542 section->sh_offset, 1,
10543 section->sh_size,
10544 _("Version Needs section"));
10545 if (!eneed)
10546 break;
10547 endbuf = (char *) eneed + section->sh_size;
10548
10549 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10550 {
10551 Elf_External_Verneed * entry;
10552 Elf_Internal_Verneed ent;
10553 unsigned long isum;
10554 int j;
10555 char * vstart;
10556
10557 vstart = ((char *) eneed) + idx;
10558 if (vstart + sizeof (*entry) > endbuf)
10559 break;
10560
10561 entry = (Elf_External_Verneed *) vstart;
10562
10563 ent.vn_version = BYTE_GET (entry->vn_version);
10564 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
10565 ent.vn_file = BYTE_GET (entry->vn_file);
10566 ent.vn_aux = BYTE_GET (entry->vn_aux);
10567 ent.vn_next = BYTE_GET (entry->vn_next);
10568
10569 printf (_(" %#06lx: Version: %d"), idx, ent.vn_version);
10570
10571 if (VALID_DYNAMIC_NAME (ent.vn_file))
10572 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
10573 else
10574 printf (_(" File: %lx"), ent.vn_file);
10575
10576 printf (_(" Cnt: %d\n"), ent.vn_cnt);
10577
10578 /* Check for overflow. */
10579 if (ent.vn_aux > (size_t) (endbuf - vstart))
10580 break;
10581 vstart += ent.vn_aux;
10582
10583 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10584 {
10585 Elf_External_Vernaux * eaux;
10586 Elf_Internal_Vernaux aux;
10587
10588 if (vstart + sizeof (*eaux) > endbuf)
10589 break;
10590 eaux = (Elf_External_Vernaux *) vstart;
10591
10592 aux.vna_hash = BYTE_GET (eaux->vna_hash);
10593 aux.vna_flags = BYTE_GET (eaux->vna_flags);
10594 aux.vna_other = BYTE_GET (eaux->vna_other);
10595 aux.vna_name = BYTE_GET (eaux->vna_name);
10596 aux.vna_next = BYTE_GET (eaux->vna_next);
10597
10598 if (VALID_DYNAMIC_NAME (aux.vna_name))
10599 printf (_(" %#06lx: Name: %s"),
10600 isum, GET_DYNAMIC_NAME (aux.vna_name));
10601 else
10602 printf (_(" %#06lx: Name index: %lx"),
10603 isum, aux.vna_name);
10604
10605 printf (_(" Flags: %s Version: %d\n"),
10606 get_ver_flags (aux.vna_flags), aux.vna_other);
10607
10608 if (aux.vna_next < sizeof (*eaux)
10609 && !(j == ent.vn_cnt - 1 && aux.vna_next == 0))
10610 {
10611 warn (_("Invalid vna_next field of %lx\n"),
10612 aux.vna_next);
10613 j = ent.vn_cnt;
10614 break;
10615 }
10616 /* Check for overflow. */
10617 if (aux.vna_next > (size_t) (endbuf - vstart))
10618 break;
10619 isum += aux.vna_next;
10620 vstart += aux.vna_next;
10621 }
10622
10623 if (j < ent.vn_cnt)
10624 warn (_("Missing Version Needs auxillary information\n"));
10625
10626 if (ent.vn_next < sizeof (*entry)
10627 && !(cnt == section->sh_info - 1 && ent.vn_next == 0))
10628 {
10629 warn (_("Invalid vn_next field of %lx\n"), ent.vn_next);
10630 cnt = section->sh_info;
10631 break;
10632 }
10633 if (ent.vn_next > (size_t) (endbuf - ((char *) eneed + idx)))
10634 break;
10635 idx += ent.vn_next;
10636 }
10637
10638 if (cnt < section->sh_info)
10639 warn (_("Missing Version Needs information\n"));
10640
10641 free (eneed);
10642 }
10643 break;
10644
10645 case SHT_GNU_versym:
10646 {
10647 Elf_Internal_Shdr * link_section;
10648 size_t total;
10649 unsigned int cnt;
10650 unsigned char * edata;
10651 unsigned short * data;
10652 char * strtab;
10653 Elf_Internal_Sym * symbols;
10654 Elf_Internal_Shdr * string_sec;
10655 unsigned long num_syms;
10656 long off;
10657
10658 if (section->sh_link >= filedata->file_header.e_shnum)
10659 break;
10660
10661 link_section = filedata->section_headers + section->sh_link;
10662 total = section->sh_size / sizeof (Elf_External_Versym);
10663
10664 if (link_section->sh_link >= filedata->file_header.e_shnum)
10665 break;
10666
10667 found = TRUE;
10668
10669 symbols = GET_ELF_SYMBOLS (filedata, link_section, & num_syms);
10670 if (symbols == NULL)
10671 break;
10672
10673 string_sec = filedata->section_headers + link_section->sh_link;
10674
10675 strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
10676 string_sec->sh_size,
10677 _("version string table"));
10678 if (!strtab)
10679 {
10680 free (symbols);
10681 break;
10682 }
10683
10684 printf (ngettext ("\nVersion symbols section '%s' "
10685 "contains %lu entry:\n",
10686 "\nVersion symbols section '%s' "
10687 "contains %lu entries:\n",
10688 total),
10689 printable_section_name (filedata, section), (unsigned long) total);
10690
10691 printf (_(" Addr: "));
10692 printf_vma (section->sh_addr);
10693 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10694 (unsigned long) section->sh_offset, section->sh_link,
10695 printable_section_name (filedata, link_section));
10696
10697 off = offset_from_vma (filedata,
10698 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10699 total * sizeof (short));
10700 edata = (unsigned char *) get_data (NULL, filedata, off, total,
10701 sizeof (short),
10702 _("version symbol data"));
10703 if (!edata)
10704 {
10705 free (strtab);
10706 free (symbols);
10707 break;
10708 }
10709
10710 data = (short unsigned int *) cmalloc (total, sizeof (short));
10711
10712 for (cnt = total; cnt --;)
10713 data[cnt] = byte_get (edata + cnt * sizeof (short),
10714 sizeof (short));
10715
10716 free (edata);
10717
10718 for (cnt = 0; cnt < total; cnt += 4)
10719 {
10720 int j, nn;
10721 char *name;
10722 char *invalid = _("*invalid*");
10723
10724 printf (" %03x:", cnt);
10725
10726 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10727 switch (data[cnt + j])
10728 {
10729 case 0:
10730 fputs (_(" 0 (*local*) "), stdout);
10731 break;
10732
10733 case 1:
10734 fputs (_(" 1 (*global*) "), stdout);
10735 break;
10736
10737 default:
10738 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10739 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10740
10741 /* If this index value is greater than the size of the symbols
10742 array, break to avoid an out-of-bounds read. */
10743 if ((unsigned long)(cnt + j) >= num_syms)
10744 {
10745 warn (_("invalid index into symbol array\n"));
10746 break;
10747 }
10748
10749 name = NULL;
10750 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10751 {
10752 Elf_Internal_Verneed ivn;
10753 unsigned long offset;
10754
10755 offset = offset_from_vma
10756 (filedata, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10757 sizeof (Elf_External_Verneed));
10758
10759 do
10760 {
10761 Elf_Internal_Vernaux ivna;
10762 Elf_External_Verneed evn;
10763 Elf_External_Vernaux evna;
10764 unsigned long a_off;
10765
10766 if (get_data (&evn, filedata, offset, sizeof (evn), 1,
10767 _("version need")) == NULL)
10768 break;
10769
10770 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10771 ivn.vn_next = BYTE_GET (evn.vn_next);
10772
10773 a_off = offset + ivn.vn_aux;
10774
10775 do
10776 {
10777 if (get_data (&evna, filedata, a_off, sizeof (evna),
10778 1, _("version need aux (2)")) == NULL)
10779 {
10780 ivna.vna_next = 0;
10781 ivna.vna_other = 0;
10782 }
10783 else
10784 {
10785 ivna.vna_next = BYTE_GET (evna.vna_next);
10786 ivna.vna_other = BYTE_GET (evna.vna_other);
10787 }
10788
10789 a_off += ivna.vna_next;
10790 }
10791 while (ivna.vna_other != data[cnt + j]
10792 && ivna.vna_next != 0);
10793
10794 if (ivna.vna_other == data[cnt + j])
10795 {
10796 ivna.vna_name = BYTE_GET (evna.vna_name);
10797
10798 if (ivna.vna_name >= string_sec->sh_size)
10799 name = invalid;
10800 else
10801 name = strtab + ivna.vna_name;
10802 break;
10803 }
10804
10805 offset += ivn.vn_next;
10806 }
10807 while (ivn.vn_next);
10808 }
10809
10810 if (data[cnt + j] != 0x8001
10811 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10812 {
10813 Elf_Internal_Verdef ivd;
10814 Elf_External_Verdef evd;
10815 unsigned long offset;
10816
10817 offset = offset_from_vma
10818 (filedata, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10819 sizeof evd);
10820
10821 do
10822 {
10823 if (get_data (&evd, filedata, offset, sizeof (evd), 1,
10824 _("version def")) == NULL)
10825 {
10826 ivd.vd_next = 0;
10827 /* PR 17531: file: 046-1082287-0.004. */
10828 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
10829 break;
10830 }
10831 else
10832 {
10833 ivd.vd_next = BYTE_GET (evd.vd_next);
10834 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10835 }
10836
10837 offset += ivd.vd_next;
10838 }
10839 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
10840 && ivd.vd_next != 0);
10841
10842 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
10843 {
10844 Elf_External_Verdaux evda;
10845 Elf_Internal_Verdaux ivda;
10846
10847 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10848
10849 if (get_data (&evda, filedata,
10850 offset - ivd.vd_next + ivd.vd_aux,
10851 sizeof (evda), 1,
10852 _("version def aux")) == NULL)
10853 break;
10854
10855 ivda.vda_name = BYTE_GET (evda.vda_name);
10856
10857 if (ivda.vda_name >= string_sec->sh_size)
10858 name = invalid;
10859 else if (name != NULL && name != invalid)
10860 name = _("*both*");
10861 else
10862 name = strtab + ivda.vda_name;
10863 }
10864 }
10865 if (name != NULL)
10866 nn += printf ("(%s%-*s",
10867 name,
10868 12 - (int) strlen (name),
10869 ")");
10870
10871 if (nn < 18)
10872 printf ("%*c", 18 - nn, ' ');
10873 }
10874
10875 putchar ('\n');
10876 }
10877
10878 free (data);
10879 free (strtab);
10880 free (symbols);
10881 }
10882 break;
10883
10884 default:
10885 break;
10886 }
10887 }
10888
10889 if (! found)
10890 printf (_("\nNo version information found in this file.\n"));
10891
10892 return TRUE;
10893 }
10894
10895 static const char *
10896 get_symbol_binding (Filedata * filedata, unsigned int binding)
10897 {
10898 static char buff[32];
10899
10900 switch (binding)
10901 {
10902 case STB_LOCAL: return "LOCAL";
10903 case STB_GLOBAL: return "GLOBAL";
10904 case STB_WEAK: return "WEAK";
10905 default:
10906 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
10907 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10908 binding);
10909 else if (binding >= STB_LOOS && binding <= STB_HIOS)
10910 {
10911 if (binding == STB_GNU_UNIQUE
10912 && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10913 /* GNU is still using the default value 0. */
10914 || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10915 return "UNIQUE";
10916 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10917 }
10918 else
10919 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
10920 return buff;
10921 }
10922 }
10923
10924 static const char *
10925 get_symbol_type (Filedata * filedata, unsigned int type)
10926 {
10927 static char buff[32];
10928
10929 switch (type)
10930 {
10931 case STT_NOTYPE: return "NOTYPE";
10932 case STT_OBJECT: return "OBJECT";
10933 case STT_FUNC: return "FUNC";
10934 case STT_SECTION: return "SECTION";
10935 case STT_FILE: return "FILE";
10936 case STT_COMMON: return "COMMON";
10937 case STT_TLS: return "TLS";
10938 case STT_RELC: return "RELC";
10939 case STT_SRELC: return "SRELC";
10940 default:
10941 if (type >= STT_LOPROC && type <= STT_HIPROC)
10942 {
10943 if (filedata->file_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10944 return "THUMB_FUNC";
10945
10946 if (filedata->file_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
10947 return "REGISTER";
10948
10949 if (filedata->file_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10950 return "PARISC_MILLI";
10951
10952 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
10953 }
10954 else if (type >= STT_LOOS && type <= STT_HIOS)
10955 {
10956 if (filedata->file_header.e_machine == EM_PARISC)
10957 {
10958 if (type == STT_HP_OPAQUE)
10959 return "HP_OPAQUE";
10960 if (type == STT_HP_STUB)
10961 return "HP_STUB";
10962 }
10963
10964 if (type == STT_GNU_IFUNC
10965 && (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10966 || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
10967 /* GNU is still using the default value 0. */
10968 || filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10969 return "IFUNC";
10970
10971 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
10972 }
10973 else
10974 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
10975 return buff;
10976 }
10977 }
10978
10979 static const char *
10980 get_symbol_visibility (unsigned int visibility)
10981 {
10982 switch (visibility)
10983 {
10984 case STV_DEFAULT: return "DEFAULT";
10985 case STV_INTERNAL: return "INTERNAL";
10986 case STV_HIDDEN: return "HIDDEN";
10987 case STV_PROTECTED: return "PROTECTED";
10988 default:
10989 error (_("Unrecognized visibility value: %u"), visibility);
10990 return _("<unknown>");
10991 }
10992 }
10993
10994 static const char *
10995 get_solaris_symbol_visibility (unsigned int visibility)
10996 {
10997 switch (visibility)
10998 {
10999 case 4: return "EXPORTED";
11000 case 5: return "SINGLETON";
11001 case 6: return "ELIMINATE";
11002 default: return get_symbol_visibility (visibility);
11003 }
11004 }
11005
11006 static const char *
11007 get_mips_symbol_other (unsigned int other)
11008 {
11009 switch (other)
11010 {
11011 case STO_OPTIONAL: return "OPTIONAL";
11012 case STO_MIPS_PLT: return "MIPS PLT";
11013 case STO_MIPS_PIC: return "MIPS PIC";
11014 case STO_MICROMIPS: return "MICROMIPS";
11015 case STO_MICROMIPS | STO_MIPS_PIC: return "MICROMIPS, MIPS PIC";
11016 case STO_MIPS16: return "MIPS16";
11017 default: return NULL;
11018 }
11019 }
11020
11021 static const char *
11022 get_ia64_symbol_other (Filedata * filedata, unsigned int other)
11023 {
11024 if (is_ia64_vms (filedata))
11025 {
11026 static char res[32];
11027
11028 res[0] = 0;
11029
11030 /* Function types is for images and .STB files only. */
11031 switch (filedata->file_header.e_type)
11032 {
11033 case ET_DYN:
11034 case ET_EXEC:
11035 switch (VMS_ST_FUNC_TYPE (other))
11036 {
11037 case VMS_SFT_CODE_ADDR:
11038 strcat (res, " CA");
11039 break;
11040 case VMS_SFT_SYMV_IDX:
11041 strcat (res, " VEC");
11042 break;
11043 case VMS_SFT_FD:
11044 strcat (res, " FD");
11045 break;
11046 case VMS_SFT_RESERVE:
11047 strcat (res, " RSV");
11048 break;
11049 default:
11050 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11051 VMS_ST_FUNC_TYPE (other));
11052 strcat (res, " <unknown>");
11053 break;
11054 }
11055 break;
11056 default:
11057 break;
11058 }
11059 switch (VMS_ST_LINKAGE (other))
11060 {
11061 case VMS_STL_IGNORE:
11062 strcat (res, " IGN");
11063 break;
11064 case VMS_STL_RESERVE:
11065 strcat (res, " RSV");
11066 break;
11067 case VMS_STL_STD:
11068 strcat (res, " STD");
11069 break;
11070 case VMS_STL_LNK:
11071 strcat (res, " LNK");
11072 break;
11073 default:
11074 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11075 VMS_ST_LINKAGE (other));
11076 strcat (res, " <unknown>");
11077 break;
11078 }
11079
11080 if (res[0] != 0)
11081 return res + 1;
11082 else
11083 return res;
11084 }
11085 return NULL;
11086 }
11087
11088 static const char *
11089 get_ppc64_symbol_other (unsigned int other)
11090 {
11091 if ((other & ~STO_PPC64_LOCAL_MASK) != 0)
11092 return NULL;
11093
11094 other >>= STO_PPC64_LOCAL_BIT;
11095 if (other <= 6)
11096 {
11097 static char buf[32];
11098 if (other >= 2)
11099 other = ppc64_decode_local_entry (other);
11100 snprintf (buf, sizeof buf, _("<localentry>: %d"), other);
11101 return buf;
11102 }
11103 return NULL;
11104 }
11105
11106 static const char *
11107 get_symbol_other (Filedata * filedata, unsigned int other)
11108 {
11109 const char * result = NULL;
11110 static char buff [32];
11111
11112 if (other == 0)
11113 return "";
11114
11115 switch (filedata->file_header.e_machine)
11116 {
11117 case EM_MIPS:
11118 result = get_mips_symbol_other (other);
11119 break;
11120 case EM_IA_64:
11121 result = get_ia64_symbol_other (filedata, other);
11122 break;
11123 case EM_PPC64:
11124 result = get_ppc64_symbol_other (other);
11125 break;
11126 default:
11127 result = NULL;
11128 break;
11129 }
11130
11131 if (result)
11132 return result;
11133
11134 snprintf (buff, sizeof buff, _("<other>: %x"), other);
11135 return buff;
11136 }
11137
11138 static const char *
11139 get_symbol_index_type (Filedata * filedata, unsigned int type)
11140 {
11141 static char buff[32];
11142
11143 switch (type)
11144 {
11145 case SHN_UNDEF: return "UND";
11146 case SHN_ABS: return "ABS";
11147 case SHN_COMMON: return "COM";
11148 default:
11149 if (type == SHN_IA_64_ANSI_COMMON
11150 && filedata->file_header.e_machine == EM_IA_64
11151 && filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
11152 return "ANSI_COM";
11153 else if ((filedata->file_header.e_machine == EM_X86_64
11154 || filedata->file_header.e_machine == EM_L1OM
11155 || filedata->file_header.e_machine == EM_K1OM)
11156 && type == SHN_X86_64_LCOMMON)
11157 return "LARGE_COM";
11158 else if ((type == SHN_MIPS_SCOMMON
11159 && filedata->file_header.e_machine == EM_MIPS)
11160 || (type == SHN_TIC6X_SCOMMON
11161 && filedata->file_header.e_machine == EM_TI_C6000))
11162 return "SCOM";
11163 else if (type == SHN_MIPS_SUNDEFINED
11164 && filedata->file_header.e_machine == EM_MIPS)
11165 return "SUND";
11166 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
11167 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
11168 else if (type >= SHN_LOOS && type <= SHN_HIOS)
11169 sprintf (buff, "OS [0x%04x]", type & 0xffff);
11170 else if (type >= SHN_LORESERVE)
11171 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
11172 else if (type >= filedata->file_header.e_shnum)
11173 sprintf (buff, _("bad section index[%3d]"), type);
11174 else
11175 sprintf (buff, "%3d", type);
11176 break;
11177 }
11178
11179 return buff;
11180 }
11181
11182 static bfd_vma *
11183 get_dynamic_data (Filedata * filedata, bfd_size_type number, unsigned int ent_size)
11184 {
11185 unsigned char * e_data;
11186 bfd_vma * i_data;
11187
11188 /* If the size_t type is smaller than the bfd_size_type, eg because
11189 you are building a 32-bit tool on a 64-bit host, then make sure
11190 that when (number) is cast to (size_t) no information is lost. */
11191 if (sizeof (size_t) < sizeof (bfd_size_type)
11192 && (bfd_size_type) ((size_t) number) != number)
11193 {
11194 error (_("Size truncation prevents reading %s elements of size %u\n"),
11195 bfd_vmatoa ("u", number), ent_size);
11196 return NULL;
11197 }
11198
11199 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11200 attempting to allocate memory when the read is bound to fail. */
11201 if (ent_size * number > filedata->file_size)
11202 {
11203 error (_("Invalid number of dynamic entries: %s\n"),
11204 bfd_vmatoa ("u", number));
11205 return NULL;
11206 }
11207
11208 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
11209 if (e_data == NULL)
11210 {
11211 error (_("Out of memory reading %s dynamic entries\n"),
11212 bfd_vmatoa ("u", number));
11213 return NULL;
11214 }
11215
11216 if (fread (e_data, ent_size, (size_t) number, filedata->handle) != number)
11217 {
11218 error (_("Unable to read in %s bytes of dynamic data\n"),
11219 bfd_vmatoa ("u", number * ent_size));
11220 free (e_data);
11221 return NULL;
11222 }
11223
11224 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
11225 if (i_data == NULL)
11226 {
11227 error (_("Out of memory allocating space for %s dynamic entries\n"),
11228 bfd_vmatoa ("u", number));
11229 free (e_data);
11230 return NULL;
11231 }
11232
11233 while (number--)
11234 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
11235
11236 free (e_data);
11237
11238 return i_data;
11239 }
11240
11241 static void
11242 print_dynamic_symbol (Filedata * filedata, bfd_vma si, unsigned long hn)
11243 {
11244 Elf_Internal_Sym * psym;
11245 int n;
11246
11247 n = print_vma (si, DEC_5);
11248 if (n < 5)
11249 fputs (&" "[n], stdout);
11250 printf (" %3lu: ", hn);
11251
11252 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
11253 {
11254 printf (_("<No info available for dynamic symbol number %lu>\n"),
11255 (unsigned long) si);
11256 return;
11257 }
11258
11259 psym = dynamic_symbols + si;
11260 print_vma (psym->st_value, LONG_HEX);
11261 putchar (' ');
11262 print_vma (psym->st_size, DEC_5);
11263
11264 printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11265 printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11266
11267 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11268 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
11269 else
11270 {
11271 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11272
11273 printf (" %-7s", get_symbol_visibility (vis));
11274 /* Check to see if any other bits in the st_other field are set.
11275 Note - displaying this information disrupts the layout of the
11276 table being generated, but for the moment this case is very
11277 rare. */
11278 if (psym->st_other ^ vis)
11279 printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11280 }
11281
11282 printf (" %3.3s ", get_symbol_index_type (filedata, psym->st_shndx));
11283 if (VALID_DYNAMIC_NAME (psym->st_name))
11284 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11285 else
11286 printf (_(" <corrupt: %14ld>"), psym->st_name);
11287 putchar ('\n');
11288 }
11289
11290 static const char *
11291 get_symbol_version_string (Filedata * filedata,
11292 bfd_boolean is_dynsym,
11293 const char * strtab,
11294 unsigned long int strtab_size,
11295 unsigned int si,
11296 Elf_Internal_Sym * psym,
11297 enum versioned_symbol_info * sym_info,
11298 unsigned short * vna_other)
11299 {
11300 unsigned char data[2];
11301 unsigned short vers_data;
11302 unsigned long offset;
11303 unsigned short max_vd_ndx;
11304
11305 if (!is_dynsym
11306 || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
11307 return NULL;
11308
11309 offset = offset_from_vma (filedata, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
11310 sizeof data + si * sizeof (vers_data));
11311
11312 if (get_data (&data, filedata, offset + si * sizeof (vers_data),
11313 sizeof (data), 1, _("version data")) == NULL)
11314 return NULL;
11315
11316 vers_data = byte_get (data, 2);
11317
11318 if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data == 0)
11319 return NULL;
11320
11321 max_vd_ndx = 0;
11322
11323 /* Usually we'd only see verdef for defined symbols, and verneed for
11324 undefined symbols. However, symbols defined by the linker in
11325 .dynbss for variables copied from a shared library in order to
11326 avoid text relocations are defined yet have verneed. We could
11327 use a heuristic to detect the special case, for example, check
11328 for verneed first on symbols defined in SHT_NOBITS sections, but
11329 it is simpler and more reliable to just look for both verdef and
11330 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11331
11332 if (psym->st_shndx != SHN_UNDEF
11333 && vers_data != 0x8001
11334 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
11335 {
11336 Elf_Internal_Verdef ivd;
11337 Elf_Internal_Verdaux ivda;
11338 Elf_External_Verdaux evda;
11339 unsigned long off;
11340
11341 off = offset_from_vma (filedata,
11342 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
11343 sizeof (Elf_External_Verdef));
11344
11345 do
11346 {
11347 Elf_External_Verdef evd;
11348
11349 if (get_data (&evd, filedata, off, sizeof (evd), 1,
11350 _("version def")) == NULL)
11351 {
11352 ivd.vd_ndx = 0;
11353 ivd.vd_aux = 0;
11354 ivd.vd_next = 0;
11355 ivd.vd_flags = 0;
11356 }
11357 else
11358 {
11359 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
11360 ivd.vd_aux = BYTE_GET (evd.vd_aux);
11361 ivd.vd_next = BYTE_GET (evd.vd_next);
11362 ivd.vd_flags = BYTE_GET (evd.vd_flags);
11363 }
11364
11365 if ((ivd.vd_ndx & VERSYM_VERSION) > max_vd_ndx)
11366 max_vd_ndx = ivd.vd_ndx & VERSYM_VERSION;
11367
11368 off += ivd.vd_next;
11369 }
11370 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
11371
11372 if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
11373 {
11374 if (ivd.vd_ndx == 1 && ivd.vd_flags == VER_FLG_BASE)
11375 return NULL;
11376
11377 off -= ivd.vd_next;
11378 off += ivd.vd_aux;
11379
11380 if (get_data (&evda, filedata, off, sizeof (evda), 1,
11381 _("version def aux")) != NULL)
11382 {
11383 ivda.vda_name = BYTE_GET (evda.vda_name);
11384
11385 if (psym->st_name != ivda.vda_name)
11386 {
11387 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
11388 ? symbol_hidden : symbol_public);
11389 return (ivda.vda_name < strtab_size
11390 ? strtab + ivda.vda_name : _("<corrupt>"));
11391 }
11392 }
11393 }
11394 }
11395
11396 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11397 {
11398 Elf_External_Verneed evn;
11399 Elf_Internal_Verneed ivn;
11400 Elf_Internal_Vernaux ivna;
11401
11402 offset = offset_from_vma (filedata,
11403 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11404 sizeof evn);
11405 do
11406 {
11407 unsigned long vna_off;
11408
11409 if (get_data (&evn, filedata, offset, sizeof (evn), 1,
11410 _("version need")) == NULL)
11411 {
11412 ivna.vna_next = 0;
11413 ivna.vna_other = 0;
11414 ivna.vna_name = 0;
11415 break;
11416 }
11417
11418 ivn.vn_aux = BYTE_GET (evn.vn_aux);
11419 ivn.vn_next = BYTE_GET (evn.vn_next);
11420
11421 vna_off = offset + ivn.vn_aux;
11422
11423 do
11424 {
11425 Elf_External_Vernaux evna;
11426
11427 if (get_data (&evna, filedata, vna_off, sizeof (evna), 1,
11428 _("version need aux (3)")) == NULL)
11429 {
11430 ivna.vna_next = 0;
11431 ivna.vna_other = 0;
11432 ivna.vna_name = 0;
11433 }
11434 else
11435 {
11436 ivna.vna_other = BYTE_GET (evna.vna_other);
11437 ivna.vna_next = BYTE_GET (evna.vna_next);
11438 ivna.vna_name = BYTE_GET (evna.vna_name);
11439 }
11440
11441 vna_off += ivna.vna_next;
11442 }
11443 while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11444
11445 if (ivna.vna_other == vers_data)
11446 break;
11447
11448 offset += ivn.vn_next;
11449 }
11450 while (ivn.vn_next != 0);
11451
11452 if (ivna.vna_other == vers_data)
11453 {
11454 *sym_info = symbol_undefined;
11455 *vna_other = ivna.vna_other;
11456 return (ivna.vna_name < strtab_size
11457 ? strtab + ivna.vna_name : _("<corrupt>"));
11458 }
11459 else if ((max_vd_ndx || (vers_data & VERSYM_VERSION) != 1)
11460 && (vers_data & VERSYM_VERSION) > max_vd_ndx)
11461 return _("<corrupt>");
11462 }
11463 return NULL;
11464 }
11465
11466 /* Dump the symbol table. */
11467 static bfd_boolean
11468 process_symbol_table (Filedata * filedata)
11469 {
11470 Elf_Internal_Shdr * section;
11471 bfd_size_type nbuckets = 0;
11472 bfd_size_type nchains = 0;
11473 bfd_vma * buckets = NULL;
11474 bfd_vma * chains = NULL;
11475 bfd_vma ngnubuckets = 0;
11476 bfd_vma * gnubuckets = NULL;
11477 bfd_vma * gnuchains = NULL;
11478 bfd_vma gnusymidx = 0;
11479 bfd_size_type ngnuchains = 0;
11480
11481 if (!do_syms && !do_dyn_syms && !do_histogram)
11482 return TRUE;
11483
11484 if (dynamic_info[DT_HASH]
11485 && (do_histogram
11486 || (do_using_dynamic
11487 && !do_dyn_syms
11488 && dynamic_strings != NULL)))
11489 {
11490 unsigned char nb[8];
11491 unsigned char nc[8];
11492 unsigned int hash_ent_size = 4;
11493
11494 if ((filedata->file_header.e_machine == EM_ALPHA
11495 || filedata->file_header.e_machine == EM_S390
11496 || filedata->file_header.e_machine == EM_S390_OLD)
11497 && filedata->file_header.e_ident[EI_CLASS] == ELFCLASS64)
11498 hash_ent_size = 8;
11499
11500 if (fseek (filedata->handle,
11501 (archive_file_offset
11502 + offset_from_vma (filedata, dynamic_info[DT_HASH],
11503 sizeof nb + sizeof nc)),
11504 SEEK_SET))
11505 {
11506 error (_("Unable to seek to start of dynamic information\n"));
11507 goto no_hash;
11508 }
11509
11510 if (fread (nb, hash_ent_size, 1, filedata->handle) != 1)
11511 {
11512 error (_("Failed to read in number of buckets\n"));
11513 goto no_hash;
11514 }
11515
11516 if (fread (nc, hash_ent_size, 1, filedata->handle) != 1)
11517 {
11518 error (_("Failed to read in number of chains\n"));
11519 goto no_hash;
11520 }
11521
11522 nbuckets = byte_get (nb, hash_ent_size);
11523 nchains = byte_get (nc, hash_ent_size);
11524
11525 buckets = get_dynamic_data (filedata, nbuckets, hash_ent_size);
11526 chains = get_dynamic_data (filedata, nchains, hash_ent_size);
11527
11528 no_hash:
11529 if (buckets == NULL || chains == NULL)
11530 {
11531 if (do_using_dynamic)
11532 return FALSE;
11533 free (buckets);
11534 free (chains);
11535 buckets = NULL;
11536 chains = NULL;
11537 nbuckets = 0;
11538 nchains = 0;
11539 }
11540 }
11541
11542 if (dynamic_info_DT_GNU_HASH
11543 && (do_histogram
11544 || (do_using_dynamic
11545 && !do_dyn_syms
11546 && dynamic_strings != NULL)))
11547 {
11548 unsigned char nb[16];
11549 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11550 bfd_vma buckets_vma;
11551
11552 if (fseek (filedata->handle,
11553 (archive_file_offset
11554 + offset_from_vma (filedata, dynamic_info_DT_GNU_HASH,
11555 sizeof nb)),
11556 SEEK_SET))
11557 {
11558 error (_("Unable to seek to start of dynamic information\n"));
11559 goto no_gnu_hash;
11560 }
11561
11562 if (fread (nb, 16, 1, filedata->handle) != 1)
11563 {
11564 error (_("Failed to read in number of buckets\n"));
11565 goto no_gnu_hash;
11566 }
11567
11568 ngnubuckets = byte_get (nb, 4);
11569 gnusymidx = byte_get (nb + 4, 4);
11570 bitmaskwords = byte_get (nb + 8, 4);
11571 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11572 if (is_32bit_elf)
11573 buckets_vma += bitmaskwords * 4;
11574 else
11575 buckets_vma += bitmaskwords * 8;
11576
11577 if (fseek (filedata->handle,
11578 (archive_file_offset
11579 + offset_from_vma (filedata, buckets_vma, 4)),
11580 SEEK_SET))
11581 {
11582 error (_("Unable to seek to start of dynamic information\n"));
11583 goto no_gnu_hash;
11584 }
11585
11586 gnubuckets = get_dynamic_data (filedata, ngnubuckets, 4);
11587
11588 if (gnubuckets == NULL)
11589 goto no_gnu_hash;
11590
11591 for (i = 0; i < ngnubuckets; i++)
11592 if (gnubuckets[i] != 0)
11593 {
11594 if (gnubuckets[i] < gnusymidx)
11595 return FALSE;
11596
11597 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11598 maxchain = gnubuckets[i];
11599 }
11600
11601 if (maxchain == 0xffffffff)
11602 goto no_gnu_hash;
11603
11604 maxchain -= gnusymidx;
11605
11606 if (fseek (filedata->handle,
11607 (archive_file_offset
11608 + offset_from_vma (filedata, buckets_vma
11609 + 4 * (ngnubuckets + maxchain), 4)),
11610 SEEK_SET))
11611 {
11612 error (_("Unable to seek to start of dynamic information\n"));
11613 goto no_gnu_hash;
11614 }
11615
11616 do
11617 {
11618 if (fread (nb, 4, 1, filedata->handle) != 1)
11619 {
11620 error (_("Failed to determine last chain length\n"));
11621 goto no_gnu_hash;
11622 }
11623
11624 if (maxchain + 1 == 0)
11625 goto no_gnu_hash;
11626
11627 ++maxchain;
11628 }
11629 while ((byte_get (nb, 4) & 1) == 0);
11630
11631 if (fseek (filedata->handle,
11632 (archive_file_offset
11633 + offset_from_vma (filedata, buckets_vma + 4 * ngnubuckets, 4)),
11634 SEEK_SET))
11635 {
11636 error (_("Unable to seek to start of dynamic information\n"));
11637 goto no_gnu_hash;
11638 }
11639
11640 gnuchains = get_dynamic_data (filedata, maxchain, 4);
11641 ngnuchains = maxchain;
11642
11643 no_gnu_hash:
11644 if (gnuchains == NULL)
11645 {
11646 free (gnubuckets);
11647 gnubuckets = NULL;
11648 ngnubuckets = 0;
11649 if (do_using_dynamic)
11650 return FALSE;
11651 }
11652 }
11653
11654 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11655 && do_syms
11656 && do_using_dynamic
11657 && dynamic_strings != NULL
11658 && dynamic_symbols != NULL)
11659 {
11660 unsigned long hn;
11661
11662 if (dynamic_info[DT_HASH])
11663 {
11664 bfd_vma si;
11665 char *visited;
11666
11667 printf (_("\nSymbol table for image:\n"));
11668 if (is_32bit_elf)
11669 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11670 else
11671 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11672
11673 visited = xcmalloc (nchains, 1);
11674 memset (visited, 0, nchains);
11675 for (hn = 0; hn < nbuckets; hn++)
11676 {
11677 for (si = buckets[hn]; si > 0; si = chains[si])
11678 {
11679 print_dynamic_symbol (filedata, si, hn);
11680 if (si >= nchains || visited[si])
11681 {
11682 error (_("histogram chain is corrupt\n"));
11683 break;
11684 }
11685 visited[si] = 1;
11686 }
11687 }
11688 free (visited);
11689 }
11690
11691 if (dynamic_info_DT_GNU_HASH)
11692 {
11693 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11694 if (is_32bit_elf)
11695 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11696 else
11697 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11698
11699 for (hn = 0; hn < ngnubuckets; ++hn)
11700 if (gnubuckets[hn] != 0)
11701 {
11702 bfd_vma si = gnubuckets[hn];
11703 bfd_vma off = si - gnusymidx;
11704
11705 do
11706 {
11707 print_dynamic_symbol (filedata, si, hn);
11708 si++;
11709 }
11710 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11711 }
11712 }
11713 }
11714 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11715 && filedata->section_headers != NULL)
11716 {
11717 unsigned int i;
11718
11719 for (i = 0, section = filedata->section_headers;
11720 i < filedata->file_header.e_shnum;
11721 i++, section++)
11722 {
11723 unsigned int si;
11724 char * strtab = NULL;
11725 unsigned long int strtab_size = 0;
11726 Elf_Internal_Sym * symtab;
11727 Elf_Internal_Sym * psym;
11728 unsigned long num_syms;
11729
11730 if ((section->sh_type != SHT_SYMTAB
11731 && section->sh_type != SHT_DYNSYM)
11732 || (!do_syms
11733 && section->sh_type == SHT_SYMTAB))
11734 continue;
11735
11736 if (section->sh_entsize == 0)
11737 {
11738 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11739 printable_section_name (filedata, section));
11740 continue;
11741 }
11742
11743 num_syms = section->sh_size / section->sh_entsize;
11744 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11745 "\nSymbol table '%s' contains %lu entries:\n",
11746 num_syms),
11747 printable_section_name (filedata, section),
11748 num_syms);
11749
11750 if (is_32bit_elf)
11751 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11752 else
11753 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11754
11755 symtab = GET_ELF_SYMBOLS (filedata, section, & num_syms);
11756 if (symtab == NULL)
11757 continue;
11758
11759 if (section->sh_link == filedata->file_header.e_shstrndx)
11760 {
11761 strtab = filedata->string_table;
11762 strtab_size = filedata->string_table_length;
11763 }
11764 else if (section->sh_link < filedata->file_header.e_shnum)
11765 {
11766 Elf_Internal_Shdr * string_sec;
11767
11768 string_sec = filedata->section_headers + section->sh_link;
11769
11770 strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset,
11771 1, string_sec->sh_size,
11772 _("string table"));
11773 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
11774 }
11775
11776 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
11777 {
11778 const char *version_string;
11779 enum versioned_symbol_info sym_info;
11780 unsigned short vna_other;
11781
11782 printf ("%6d: ", si);
11783 print_vma (psym->st_value, LONG_HEX);
11784 putchar (' ');
11785 print_vma (psym->st_size, DEC_5);
11786 printf (" %-7s", get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)));
11787 printf (" %-6s", get_symbol_binding (filedata, ELF_ST_BIND (psym->st_info)));
11788 if (filedata->file_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11789 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
11790 else
11791 {
11792 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11793
11794 printf (" %-7s", get_symbol_visibility (vis));
11795 /* Check to see if any other bits in the st_other field are set.
11796 Note - displaying this information disrupts the layout of the
11797 table being generated, but for the moment this case is very rare. */
11798 if (psym->st_other ^ vis)
11799 printf (" [%s] ", get_symbol_other (filedata, psym->st_other ^ vis));
11800 }
11801 printf (" %4s ", get_symbol_index_type (filedata, psym->st_shndx));
11802 print_symbol (25, psym->st_name < strtab_size
11803 ? strtab + psym->st_name : _("<corrupt>"));
11804
11805 version_string
11806 = get_symbol_version_string (filedata,
11807 section->sh_type == SHT_DYNSYM,
11808 strtab, strtab_size, si,
11809 psym, &sym_info, &vna_other);
11810 if (version_string)
11811 {
11812 if (sym_info == symbol_undefined)
11813 printf ("@%s (%d)", version_string, vna_other);
11814 else
11815 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11816 version_string);
11817 }
11818
11819 putchar ('\n');
11820
11821 if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
11822 && si >= section->sh_info
11823 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11824 && filedata->file_header.e_machine != EM_MIPS
11825 /* Solaris binaries have been found to violate this requirement as
11826 well. Not sure if this is a bug or an ABI requirement. */
11827 && filedata->file_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
11828 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11829 si, printable_section_name (filedata, section), section->sh_info);
11830 }
11831
11832 free (symtab);
11833 if (strtab != filedata->string_table)
11834 free (strtab);
11835 }
11836 }
11837 else if (do_syms)
11838 printf
11839 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11840
11841 if (do_histogram && buckets != NULL)
11842 {
11843 unsigned long * lengths;
11844 unsigned long * counts;
11845 unsigned long hn;
11846 bfd_vma si;
11847 unsigned long maxlength = 0;
11848 unsigned long nzero_counts = 0;
11849 unsigned long nsyms = 0;
11850 char *visited;
11851
11852 printf (ngettext ("\nHistogram for bucket list length "
11853 "(total of %lu bucket):\n",
11854 "\nHistogram for bucket list length "
11855 "(total of %lu buckets):\n",
11856 (unsigned long) nbuckets),
11857 (unsigned long) nbuckets);
11858
11859 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
11860 if (lengths == NULL)
11861 {
11862 error (_("Out of memory allocating space for histogram buckets\n"));
11863 return FALSE;
11864 }
11865 visited = xcmalloc (nchains, 1);
11866 memset (visited, 0, nchains);
11867
11868 printf (_(" Length Number %% of total Coverage\n"));
11869 for (hn = 0; hn < nbuckets; ++hn)
11870 {
11871 for (si = buckets[hn]; si > 0; si = chains[si])
11872 {
11873 ++nsyms;
11874 if (maxlength < ++lengths[hn])
11875 ++maxlength;
11876 if (si >= nchains || visited[si])
11877 {
11878 error (_("histogram chain is corrupt\n"));
11879 break;
11880 }
11881 visited[si] = 1;
11882 }
11883 }
11884 free (visited);
11885
11886 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11887 if (counts == NULL)
11888 {
11889 free (lengths);
11890 error (_("Out of memory allocating space for histogram counts\n"));
11891 return FALSE;
11892 }
11893
11894 for (hn = 0; hn < nbuckets; ++hn)
11895 ++counts[lengths[hn]];
11896
11897 if (nbuckets > 0)
11898 {
11899 unsigned long i;
11900 printf (" 0 %-10lu (%5.1f%%)\n",
11901 counts[0], (counts[0] * 100.0) / nbuckets);
11902 for (i = 1; i <= maxlength; ++i)
11903 {
11904 nzero_counts += counts[i] * i;
11905 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11906 i, counts[i], (counts[i] * 100.0) / nbuckets,
11907 (nzero_counts * 100.0) / nsyms);
11908 }
11909 }
11910
11911 free (counts);
11912 free (lengths);
11913 }
11914
11915 if (buckets != NULL)
11916 {
11917 free (buckets);
11918 free (chains);
11919 }
11920
11921 if (do_histogram && gnubuckets != NULL)
11922 {
11923 unsigned long * lengths;
11924 unsigned long * counts;
11925 unsigned long hn;
11926 unsigned long maxlength = 0;
11927 unsigned long nzero_counts = 0;
11928 unsigned long nsyms = 0;
11929
11930 printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
11931 "(total of %lu bucket):\n",
11932 "\nHistogram for `.gnu.hash' bucket list length "
11933 "(total of %lu buckets):\n",
11934 (unsigned long) ngnubuckets),
11935 (unsigned long) ngnubuckets);
11936
11937 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
11938 if (lengths == NULL)
11939 {
11940 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11941 return FALSE;
11942 }
11943
11944 printf (_(" Length Number %% of total Coverage\n"));
11945
11946 for (hn = 0; hn < ngnubuckets; ++hn)
11947 if (gnubuckets[hn] != 0)
11948 {
11949 bfd_vma off, length = 1;
11950
11951 for (off = gnubuckets[hn] - gnusymidx;
11952 /* PR 17531 file: 010-77222-0.004. */
11953 off < ngnuchains && (gnuchains[off] & 1) == 0;
11954 ++off)
11955 ++length;
11956 lengths[hn] = length;
11957 if (length > maxlength)
11958 maxlength = length;
11959 nsyms += length;
11960 }
11961
11962 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11963 if (counts == NULL)
11964 {
11965 free (lengths);
11966 error (_("Out of memory allocating space for gnu histogram counts\n"));
11967 return FALSE;
11968 }
11969
11970 for (hn = 0; hn < ngnubuckets; ++hn)
11971 ++counts[lengths[hn]];
11972
11973 if (ngnubuckets > 0)
11974 {
11975 unsigned long j;
11976 printf (" 0 %-10lu (%5.1f%%)\n",
11977 counts[0], (counts[0] * 100.0) / ngnubuckets);
11978 for (j = 1; j <= maxlength; ++j)
11979 {
11980 nzero_counts += counts[j] * j;
11981 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11982 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11983 (nzero_counts * 100.0) / nsyms);
11984 }
11985 }
11986
11987 free (counts);
11988 free (lengths);
11989 free (gnubuckets);
11990 free (gnuchains);
11991 }
11992
11993 return TRUE;
11994 }
11995
11996 static bfd_boolean
11997 process_syminfo (Filedata * filedata ATTRIBUTE_UNUSED)
11998 {
11999 unsigned int i;
12000
12001 if (dynamic_syminfo == NULL
12002 || !do_dynamic)
12003 /* No syminfo, this is ok. */
12004 return TRUE;
12005
12006 /* There better should be a dynamic symbol section. */
12007 if (dynamic_symbols == NULL || dynamic_strings == NULL)
12008 return FALSE;
12009
12010 if (dynamic_addr)
12011 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12012 "contains %d entry:\n",
12013 "\nDynamic info segment at offset 0x%lx "
12014 "contains %d entries:\n",
12015 dynamic_syminfo_nent),
12016 dynamic_syminfo_offset, dynamic_syminfo_nent);
12017
12018 printf (_(" Num: Name BoundTo Flags\n"));
12019 for (i = 0; i < dynamic_syminfo_nent; ++i)
12020 {
12021 unsigned short int flags = dynamic_syminfo[i].si_flags;
12022
12023 printf ("%4d: ", i);
12024 if (i >= num_dynamic_syms)
12025 printf (_("<corrupt index>"));
12026 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
12027 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
12028 else
12029 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
12030 putchar (' ');
12031
12032 switch (dynamic_syminfo[i].si_boundto)
12033 {
12034 case SYMINFO_BT_SELF:
12035 fputs ("SELF ", stdout);
12036 break;
12037 case SYMINFO_BT_PARENT:
12038 fputs ("PARENT ", stdout);
12039 break;
12040 default:
12041 if (dynamic_syminfo[i].si_boundto > 0
12042 && dynamic_syminfo[i].si_boundto < dynamic_nent
12043 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
12044 {
12045 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
12046 putchar (' ' );
12047 }
12048 else
12049 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
12050 break;
12051 }
12052
12053 if (flags & SYMINFO_FLG_DIRECT)
12054 printf (" DIRECT");
12055 if (flags & SYMINFO_FLG_PASSTHRU)
12056 printf (" PASSTHRU");
12057 if (flags & SYMINFO_FLG_COPY)
12058 printf (" COPY");
12059 if (flags & SYMINFO_FLG_LAZYLOAD)
12060 printf (" LAZYLOAD");
12061
12062 puts ("");
12063 }
12064
12065 return TRUE;
12066 }
12067
12068 #define IN_RANGE(START,END,ADDR,OFF) \
12069 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
12070
12071 /* Check to see if the given reloc needs to be handled in a target specific
12072 manner. If so then process the reloc and return TRUE otherwise return
12073 FALSE.
12074
12075 If called with reloc == NULL, then this is a signal that reloc processing
12076 for the current section has finished, and any saved state should be
12077 discarded. */
12078
12079 static bfd_boolean
12080 target_specific_reloc_handling (Filedata * filedata,
12081 Elf_Internal_Rela * reloc,
12082 unsigned char * start,
12083 unsigned char * end,
12084 Elf_Internal_Sym * symtab,
12085 unsigned long num_syms)
12086 {
12087 unsigned int reloc_type = 0;
12088 unsigned long sym_index = 0;
12089
12090 if (reloc)
12091 {
12092 reloc_type = get_reloc_type (filedata, reloc->r_info);
12093 sym_index = get_reloc_symindex (reloc->r_info);
12094 }
12095
12096 switch (filedata->file_header.e_machine)
12097 {
12098 case EM_MSP430:
12099 case EM_MSP430_OLD:
12100 {
12101 static Elf_Internal_Sym * saved_sym = NULL;
12102
12103 if (reloc == NULL)
12104 {
12105 saved_sym = NULL;
12106 return TRUE;
12107 }
12108
12109 switch (reloc_type)
12110 {
12111 case 10: /* R_MSP430_SYM_DIFF */
12112 if (uses_msp430x_relocs (filedata))
12113 break;
12114 /* Fall through. */
12115 case 21: /* R_MSP430X_SYM_DIFF */
12116 /* PR 21139. */
12117 if (sym_index >= num_syms)
12118 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12119 sym_index);
12120 else
12121 saved_sym = symtab + sym_index;
12122 return TRUE;
12123
12124 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12125 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12126 goto handle_sym_diff;
12127
12128 case 5: /* R_MSP430_16_BYTE */
12129 case 9: /* R_MSP430_8 */
12130 if (uses_msp430x_relocs (filedata))
12131 break;
12132 goto handle_sym_diff;
12133
12134 case 2: /* R_MSP430_ABS16 */
12135 case 15: /* R_MSP430X_ABS16 */
12136 if (! uses_msp430x_relocs (filedata))
12137 break;
12138 goto handle_sym_diff;
12139
12140 handle_sym_diff:
12141 if (saved_sym != NULL)
12142 {
12143 int reloc_size = reloc_type == 1 ? 4 : 2;
12144 bfd_vma value;
12145
12146 if (sym_index >= num_syms)
12147 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12148 sym_index);
12149 else
12150 {
12151 value = reloc->r_addend + (symtab[sym_index].st_value
12152 - saved_sym->st_value);
12153
12154 if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12155 byte_put (start + reloc->r_offset, value, reloc_size);
12156 else
12157 /* PR 21137 */
12158 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12159 (long) reloc->r_offset);
12160 }
12161
12162 saved_sym = NULL;
12163 return TRUE;
12164 }
12165 break;
12166
12167 default:
12168 if (saved_sym != NULL)
12169 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12170 break;
12171 }
12172 break;
12173 }
12174
12175 case EM_MN10300:
12176 case EM_CYGNUS_MN10300:
12177 {
12178 static Elf_Internal_Sym * saved_sym = NULL;
12179
12180 if (reloc == NULL)
12181 {
12182 saved_sym = NULL;
12183 return TRUE;
12184 }
12185
12186 switch (reloc_type)
12187 {
12188 case 34: /* R_MN10300_ALIGN */
12189 return TRUE;
12190 case 33: /* R_MN10300_SYM_DIFF */
12191 if (sym_index >= num_syms)
12192 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12193 sym_index);
12194 else
12195 saved_sym = symtab + sym_index;
12196 return TRUE;
12197
12198 case 1: /* R_MN10300_32 */
12199 case 2: /* R_MN10300_16 */
12200 if (saved_sym != NULL)
12201 {
12202 int reloc_size = reloc_type == 1 ? 4 : 2;
12203 bfd_vma value;
12204
12205 if (sym_index >= num_syms)
12206 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12207 sym_index);
12208 else
12209 {
12210 value = reloc->r_addend + (symtab[sym_index].st_value
12211 - saved_sym->st_value);
12212
12213 if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
12214 byte_put (start + reloc->r_offset, value, reloc_size);
12215 else
12216 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12217 (long) reloc->r_offset);
12218 }
12219
12220 saved_sym = NULL;
12221 return TRUE;
12222 }
12223 break;
12224 default:
12225 if (saved_sym != NULL)
12226 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12227 break;
12228 }
12229 break;
12230 }
12231
12232 case EM_RL78:
12233 {
12234 static bfd_vma saved_sym1 = 0;
12235 static bfd_vma saved_sym2 = 0;
12236 static bfd_vma value;
12237
12238 if (reloc == NULL)
12239 {
12240 saved_sym1 = saved_sym2 = 0;
12241 return TRUE;
12242 }
12243
12244 switch (reloc_type)
12245 {
12246 case 0x80: /* R_RL78_SYM. */
12247 saved_sym1 = saved_sym2;
12248 if (sym_index >= num_syms)
12249 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12250 sym_index);
12251 else
12252 {
12253 saved_sym2 = symtab[sym_index].st_value;
12254 saved_sym2 += reloc->r_addend;
12255 }
12256 return TRUE;
12257
12258 case 0x83: /* R_RL78_OPsub. */
12259 value = saved_sym1 - saved_sym2;
12260 saved_sym2 = saved_sym1 = 0;
12261 return TRUE;
12262 break;
12263
12264 case 0x41: /* R_RL78_ABS32. */
12265 if (IN_RANGE (start, end, start + reloc->r_offset, 4))
12266 byte_put (start + reloc->r_offset, value, 4);
12267 else
12268 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12269 (long) reloc->r_offset);
12270 value = 0;
12271 return TRUE;
12272
12273 case 0x43: /* R_RL78_ABS16. */
12274 if (IN_RANGE (start, end, start + reloc->r_offset, 2))
12275 byte_put (start + reloc->r_offset, value, 2);
12276 else
12277 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12278 (long) reloc->r_offset);
12279 value = 0;
12280 return TRUE;
12281
12282 default:
12283 break;
12284 }
12285 break;
12286 }
12287 }
12288
12289 return FALSE;
12290 }
12291
12292 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12293 DWARF debug sections. This is a target specific test. Note - we do not
12294 go through the whole including-target-headers-multiple-times route, (as
12295 we have already done with <elf/h8.h>) because this would become very
12296 messy and even then this function would have to contain target specific
12297 information (the names of the relocs instead of their numeric values).
12298 FIXME: This is not the correct way to solve this problem. The proper way
12299 is to have target specific reloc sizing and typing functions created by
12300 the reloc-macros.h header, in the same way that it already creates the
12301 reloc naming functions. */
12302
12303 static bfd_boolean
12304 is_32bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12305 {
12306 /* Please keep this table alpha-sorted for ease of visual lookup. */
12307 switch (filedata->file_header.e_machine)
12308 {
12309 case EM_386:
12310 case EM_IAMCU:
12311 return reloc_type == 1; /* R_386_32. */
12312 case EM_68K:
12313 return reloc_type == 1; /* R_68K_32. */
12314 case EM_860:
12315 return reloc_type == 1; /* R_860_32. */
12316 case EM_960:
12317 return reloc_type == 2; /* R_960_32. */
12318 case EM_AARCH64:
12319 return (reloc_type == 258
12320 || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12321 case EM_ADAPTEVA_EPIPHANY:
12322 return reloc_type == 3;
12323 case EM_ALPHA:
12324 return reloc_type == 1; /* R_ALPHA_REFLONG. */
12325 case EM_ARC:
12326 return reloc_type == 1; /* R_ARC_32. */
12327 case EM_ARC_COMPACT:
12328 case EM_ARC_COMPACT2:
12329 return reloc_type == 4; /* R_ARC_32. */
12330 case EM_ARM:
12331 return reloc_type == 2; /* R_ARM_ABS32 */
12332 case EM_AVR_OLD:
12333 case EM_AVR:
12334 return reloc_type == 1;
12335 case EM_BLACKFIN:
12336 return reloc_type == 0x12; /* R_byte4_data. */
12337 case EM_CRIS:
12338 return reloc_type == 3; /* R_CRIS_32. */
12339 case EM_CR16:
12340 return reloc_type == 3; /* R_CR16_NUM32. */
12341 case EM_CRX:
12342 return reloc_type == 15; /* R_CRX_NUM32. */
12343 case EM_CSKY:
12344 return reloc_type == 1; /* R_CKCORE_ADDR32. */
12345 case EM_CYGNUS_FRV:
12346 return reloc_type == 1;
12347 case EM_CYGNUS_D10V:
12348 case EM_D10V:
12349 return reloc_type == 6; /* R_D10V_32. */
12350 case EM_CYGNUS_D30V:
12351 case EM_D30V:
12352 return reloc_type == 12; /* R_D30V_32_NORMAL. */
12353 case EM_DLX:
12354 return reloc_type == 3; /* R_DLX_RELOC_32. */
12355 case EM_CYGNUS_FR30:
12356 case EM_FR30:
12357 return reloc_type == 3; /* R_FR30_32. */
12358 case EM_FT32:
12359 return reloc_type == 1; /* R_FT32_32. */
12360 case EM_H8S:
12361 case EM_H8_300:
12362 case EM_H8_300H:
12363 return reloc_type == 1; /* R_H8_DIR32. */
12364 case EM_IA_64:
12365 return (reloc_type == 0x64 /* R_IA64_SECREL32MSB. */
12366 || reloc_type == 0x65 /* R_IA64_SECREL32LSB. */
12367 || reloc_type == 0x24 /* R_IA64_DIR32MSB. */
12368 || reloc_type == 0x25 /* R_IA64_DIR32LSB. */);
12369 case EM_IP2K_OLD:
12370 case EM_IP2K:
12371 return reloc_type == 2; /* R_IP2K_32. */
12372 case EM_IQ2000:
12373 return reloc_type == 2; /* R_IQ2000_32. */
12374 case EM_LATTICEMICO32:
12375 return reloc_type == 3; /* R_LM32_32. */
12376 case EM_M32C_OLD:
12377 case EM_M32C:
12378 return reloc_type == 3; /* R_M32C_32. */
12379 case EM_M32R:
12380 return reloc_type == 34; /* R_M32R_32_RELA. */
12381 case EM_68HC11:
12382 case EM_68HC12:
12383 return reloc_type == 6; /* R_M68HC11_32. */
12384 case EM_S12Z:
12385 return reloc_type == 6; /* R_S12Z_EXT32. */
12386 case EM_MCORE:
12387 return reloc_type == 1; /* R_MCORE_ADDR32. */
12388 case EM_CYGNUS_MEP:
12389 return reloc_type == 4; /* R_MEP_32. */
12390 case EM_METAG:
12391 return reloc_type == 2; /* R_METAG_ADDR32. */
12392 case EM_MICROBLAZE:
12393 return reloc_type == 1; /* R_MICROBLAZE_32. */
12394 case EM_MIPS:
12395 return reloc_type == 2; /* R_MIPS_32. */
12396 case EM_MMIX:
12397 return reloc_type == 4; /* R_MMIX_32. */
12398 case EM_CYGNUS_MN10200:
12399 case EM_MN10200:
12400 return reloc_type == 1; /* R_MN10200_32. */
12401 case EM_CYGNUS_MN10300:
12402 case EM_MN10300:
12403 return reloc_type == 1; /* R_MN10300_32. */
12404 case EM_MOXIE:
12405 return reloc_type == 1; /* R_MOXIE_32. */
12406 case EM_MSP430_OLD:
12407 case EM_MSP430:
12408 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12409 case EM_MT:
12410 return reloc_type == 2; /* R_MT_32. */
12411 case EM_NDS32:
12412 return reloc_type == 20; /* R_NDS32_RELA. */
12413 case EM_ALTERA_NIOS2:
12414 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
12415 case EM_NIOS32:
12416 return reloc_type == 1; /* R_NIOS_32. */
12417 case EM_OR1K:
12418 return reloc_type == 1; /* R_OR1K_32. */
12419 case EM_PARISC:
12420 return (reloc_type == 1 /* R_PARISC_DIR32. */
12421 || reloc_type == 2 /* R_PARISC_DIR21L. */
12422 || reloc_type == 41); /* R_PARISC_SECREL32. */
12423 case EM_PJ:
12424 case EM_PJ_OLD:
12425 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
12426 case EM_PPC64:
12427 return reloc_type == 1; /* R_PPC64_ADDR32. */
12428 case EM_PPC:
12429 return reloc_type == 1; /* R_PPC_ADDR32. */
12430 case EM_TI_PRU:
12431 return reloc_type == 11; /* R_PRU_BFD_RELOC_32. */
12432 case EM_RISCV:
12433 return reloc_type == 1; /* R_RISCV_32. */
12434 case EM_RL78:
12435 return reloc_type == 1; /* R_RL78_DIR32. */
12436 case EM_RX:
12437 return reloc_type == 1; /* R_RX_DIR32. */
12438 case EM_S370:
12439 return reloc_type == 1; /* R_I370_ADDR31. */
12440 case EM_S390_OLD:
12441 case EM_S390:
12442 return reloc_type == 4; /* R_S390_32. */
12443 case EM_SCORE:
12444 return reloc_type == 8; /* R_SCORE_ABS32. */
12445 case EM_SH:
12446 return reloc_type == 1; /* R_SH_DIR32. */
12447 case EM_SPARC32PLUS:
12448 case EM_SPARCV9:
12449 case EM_SPARC:
12450 return reloc_type == 3 /* R_SPARC_32. */
12451 || reloc_type == 23; /* R_SPARC_UA32. */
12452 case EM_SPU:
12453 return reloc_type == 6; /* R_SPU_ADDR32 */
12454 case EM_TI_C6000:
12455 return reloc_type == 1; /* R_C6000_ABS32. */
12456 case EM_TILEGX:
12457 return reloc_type == 2; /* R_TILEGX_32. */
12458 case EM_TILEPRO:
12459 return reloc_type == 1; /* R_TILEPRO_32. */
12460 case EM_CYGNUS_V850:
12461 case EM_V850:
12462 return reloc_type == 6; /* R_V850_ABS32. */
12463 case EM_V800:
12464 return reloc_type == 0x33; /* R_V810_WORD. */
12465 case EM_VAX:
12466 return reloc_type == 1; /* R_VAX_32. */
12467 case EM_VISIUM:
12468 return reloc_type == 3; /* R_VISIUM_32. */
12469 case EM_WEBASSEMBLY:
12470 return reloc_type == 1; /* R_WASM32_32. */
12471 case EM_X86_64:
12472 case EM_L1OM:
12473 case EM_K1OM:
12474 return reloc_type == 10; /* R_X86_64_32. */
12475 case EM_XC16X:
12476 case EM_C166:
12477 return reloc_type == 3; /* R_XC16C_ABS_32. */
12478 case EM_XGATE:
12479 return reloc_type == 4; /* R_XGATE_32. */
12480 case EM_XSTORMY16:
12481 return reloc_type == 1; /* R_XSTROMY16_32. */
12482 case EM_XTENSA_OLD:
12483 case EM_XTENSA:
12484 return reloc_type == 1; /* R_XTENSA_32. */
12485 default:
12486 {
12487 static unsigned int prev_warn = 0;
12488
12489 /* Avoid repeating the same warning multiple times. */
12490 if (prev_warn != filedata->file_header.e_machine)
12491 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12492 filedata->file_header.e_machine);
12493 prev_warn = filedata->file_header.e_machine;
12494 return FALSE;
12495 }
12496 }
12497 }
12498
12499 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12500 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12501
12502 static bfd_boolean
12503 is_32bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12504 {
12505 switch (filedata->file_header.e_machine)
12506 /* Please keep this table alpha-sorted for ease of visual lookup. */
12507 {
12508 case EM_386:
12509 case EM_IAMCU:
12510 return reloc_type == 2; /* R_386_PC32. */
12511 case EM_68K:
12512 return reloc_type == 4; /* R_68K_PC32. */
12513 case EM_AARCH64:
12514 return reloc_type == 261; /* R_AARCH64_PREL32 */
12515 case EM_ADAPTEVA_EPIPHANY:
12516 return reloc_type == 6;
12517 case EM_ALPHA:
12518 return reloc_type == 10; /* R_ALPHA_SREL32. */
12519 case EM_ARC_COMPACT:
12520 case EM_ARC_COMPACT2:
12521 return reloc_type == 49; /* R_ARC_32_PCREL. */
12522 case EM_ARM:
12523 return reloc_type == 3; /* R_ARM_REL32 */
12524 case EM_AVR_OLD:
12525 case EM_AVR:
12526 return reloc_type == 36; /* R_AVR_32_PCREL. */
12527 case EM_MICROBLAZE:
12528 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
12529 case EM_OR1K:
12530 return reloc_type == 9; /* R_OR1K_32_PCREL. */
12531 case EM_PARISC:
12532 return reloc_type == 9; /* R_PARISC_PCREL32. */
12533 case EM_PPC:
12534 return reloc_type == 26; /* R_PPC_REL32. */
12535 case EM_PPC64:
12536 return reloc_type == 26; /* R_PPC64_REL32. */
12537 case EM_S390_OLD:
12538 case EM_S390:
12539 return reloc_type == 5; /* R_390_PC32. */
12540 case EM_SH:
12541 return reloc_type == 2; /* R_SH_REL32. */
12542 case EM_SPARC32PLUS:
12543 case EM_SPARCV9:
12544 case EM_SPARC:
12545 return reloc_type == 6; /* R_SPARC_DISP32. */
12546 case EM_SPU:
12547 return reloc_type == 13; /* R_SPU_REL32. */
12548 case EM_TILEGX:
12549 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
12550 case EM_TILEPRO:
12551 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
12552 case EM_VISIUM:
12553 return reloc_type == 6; /* R_VISIUM_32_PCREL */
12554 case EM_X86_64:
12555 case EM_L1OM:
12556 case EM_K1OM:
12557 return reloc_type == 2; /* R_X86_64_PC32. */
12558 case EM_XTENSA_OLD:
12559 case EM_XTENSA:
12560 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
12561 default:
12562 /* Do not abort or issue an error message here. Not all targets use
12563 pc-relative 32-bit relocs in their DWARF debug information and we
12564 have already tested for target coverage in is_32bit_abs_reloc. A
12565 more helpful warning message will be generated by apply_relocations
12566 anyway, so just return. */
12567 return FALSE;
12568 }
12569 }
12570
12571 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12572 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12573
12574 static bfd_boolean
12575 is_64bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12576 {
12577 switch (filedata->file_header.e_machine)
12578 {
12579 case EM_AARCH64:
12580 return reloc_type == 257; /* R_AARCH64_ABS64. */
12581 case EM_ALPHA:
12582 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
12583 case EM_IA_64:
12584 return (reloc_type == 0x26 /* R_IA64_DIR64MSB. */
12585 || reloc_type == 0x27 /* R_IA64_DIR64LSB. */);
12586 case EM_PARISC:
12587 return reloc_type == 80; /* R_PARISC_DIR64. */
12588 case EM_PPC64:
12589 return reloc_type == 38; /* R_PPC64_ADDR64. */
12590 case EM_RISCV:
12591 return reloc_type == 2; /* R_RISCV_64. */
12592 case EM_SPARC32PLUS:
12593 case EM_SPARCV9:
12594 case EM_SPARC:
12595 return reloc_type == 32 /* R_SPARC_64. */
12596 || reloc_type == 54; /* R_SPARC_UA64. */
12597 case EM_X86_64:
12598 case EM_L1OM:
12599 case EM_K1OM:
12600 return reloc_type == 1; /* R_X86_64_64. */
12601 case EM_S390_OLD:
12602 case EM_S390:
12603 return reloc_type == 22; /* R_S390_64. */
12604 case EM_TILEGX:
12605 return reloc_type == 1; /* R_TILEGX_64. */
12606 case EM_MIPS:
12607 return reloc_type == 18; /* R_MIPS_64. */
12608 default:
12609 return FALSE;
12610 }
12611 }
12612
12613 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12614 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12615
12616 static bfd_boolean
12617 is_64bit_pcrel_reloc (Filedata * filedata, unsigned int reloc_type)
12618 {
12619 switch (filedata->file_header.e_machine)
12620 {
12621 case EM_AARCH64:
12622 return reloc_type == 260; /* R_AARCH64_PREL64. */
12623 case EM_ALPHA:
12624 return reloc_type == 11; /* R_ALPHA_SREL64. */
12625 case EM_IA_64:
12626 return (reloc_type == 0x4e /* R_IA64_PCREL64MSB. */
12627 || reloc_type == 0x4f /* R_IA64_PCREL64LSB. */);
12628 case EM_PARISC:
12629 return reloc_type == 72; /* R_PARISC_PCREL64. */
12630 case EM_PPC64:
12631 return reloc_type == 44; /* R_PPC64_REL64. */
12632 case EM_SPARC32PLUS:
12633 case EM_SPARCV9:
12634 case EM_SPARC:
12635 return reloc_type == 46; /* R_SPARC_DISP64. */
12636 case EM_X86_64:
12637 case EM_L1OM:
12638 case EM_K1OM:
12639 return reloc_type == 24; /* R_X86_64_PC64. */
12640 case EM_S390_OLD:
12641 case EM_S390:
12642 return reloc_type == 23; /* R_S390_PC64. */
12643 case EM_TILEGX:
12644 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
12645 default:
12646 return FALSE;
12647 }
12648 }
12649
12650 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12651 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12652
12653 static bfd_boolean
12654 is_24bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12655 {
12656 switch (filedata->file_header.e_machine)
12657 {
12658 case EM_CYGNUS_MN10200:
12659 case EM_MN10200:
12660 return reloc_type == 4; /* R_MN10200_24. */
12661 case EM_FT32:
12662 return reloc_type == 5; /* R_FT32_20. */
12663 default:
12664 return FALSE;
12665 }
12666 }
12667
12668 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12669 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12670
12671 static bfd_boolean
12672 is_16bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12673 {
12674 /* Please keep this table alpha-sorted for ease of visual lookup. */
12675 switch (filedata->file_header.e_machine)
12676 {
12677 case EM_ARC:
12678 case EM_ARC_COMPACT:
12679 case EM_ARC_COMPACT2:
12680 return reloc_type == 2; /* R_ARC_16. */
12681 case EM_ADAPTEVA_EPIPHANY:
12682 return reloc_type == 5;
12683 case EM_AVR_OLD:
12684 case EM_AVR:
12685 return reloc_type == 4; /* R_AVR_16. */
12686 case EM_CYGNUS_D10V:
12687 case EM_D10V:
12688 return reloc_type == 3; /* R_D10V_16. */
12689 case EM_FT32:
12690 return reloc_type == 2; /* R_FT32_16. */
12691 case EM_H8S:
12692 case EM_H8_300:
12693 case EM_H8_300H:
12694 return reloc_type == R_H8_DIR16;
12695 case EM_IP2K_OLD:
12696 case EM_IP2K:
12697 return reloc_type == 1; /* R_IP2K_16. */
12698 case EM_M32C_OLD:
12699 case EM_M32C:
12700 return reloc_type == 1; /* R_M32C_16 */
12701 case EM_CYGNUS_MN10200:
12702 case EM_MN10200:
12703 return reloc_type == 2; /* R_MN10200_16. */
12704 case EM_CYGNUS_MN10300:
12705 case EM_MN10300:
12706 return reloc_type == 2; /* R_MN10300_16. */
12707 case EM_MSP430:
12708 if (uses_msp430x_relocs (filedata))
12709 return reloc_type == 2; /* R_MSP430_ABS16. */
12710 /* Fall through. */
12711 case EM_MSP430_OLD:
12712 return reloc_type == 5; /* R_MSP430_16_BYTE. */
12713 case EM_NDS32:
12714 return reloc_type == 19; /* R_NDS32_RELA. */
12715 case EM_ALTERA_NIOS2:
12716 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
12717 case EM_NIOS32:
12718 return reloc_type == 9; /* R_NIOS_16. */
12719 case EM_OR1K:
12720 return reloc_type == 2; /* R_OR1K_16. */
12721 case EM_RISCV:
12722 return reloc_type == 55; /* R_RISCV_SET16. */
12723 case EM_TI_PRU:
12724 return reloc_type == 8; /* R_PRU_BFD_RELOC_16. */
12725 case EM_TI_C6000:
12726 return reloc_type == 2; /* R_C6000_ABS16. */
12727 case EM_VISIUM:
12728 return reloc_type == 2; /* R_VISIUM_16. */
12729 case EM_XC16X:
12730 case EM_C166:
12731 return reloc_type == 2; /* R_XC16C_ABS_16. */
12732 case EM_XGATE:
12733 return reloc_type == 3; /* R_XGATE_16. */
12734 default:
12735 return FALSE;
12736 }
12737 }
12738
12739 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12740 a 8-bit absolute RELA relocation used in DWARF debug sections. */
12741
12742 static bfd_boolean
12743 is_8bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12744 {
12745 switch (filedata->file_header.e_machine)
12746 {
12747 case EM_RISCV:
12748 return reloc_type == 54; /* R_RISCV_SET8. */
12749 default:
12750 return FALSE;
12751 }
12752 }
12753
12754 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12755 a 6-bit absolute RELA relocation used in DWARF debug sections. */
12756
12757 static bfd_boolean
12758 is_6bit_abs_reloc (Filedata * filedata, unsigned int reloc_type)
12759 {
12760 switch (filedata->file_header.e_machine)
12761 {
12762 case EM_RISCV:
12763 return reloc_type == 53; /* R_RISCV_SET6. */
12764 default:
12765 return FALSE;
12766 }
12767 }
12768
12769 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12770 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
12771
12772 static bfd_boolean
12773 is_32bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12774 {
12775 /* Please keep this table alpha-sorted for ease of visual lookup. */
12776 switch (filedata->file_header.e_machine)
12777 {
12778 case EM_RISCV:
12779 return reloc_type == 35; /* R_RISCV_ADD32. */
12780 default:
12781 return FALSE;
12782 }
12783 }
12784
12785 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12786 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
12787
12788 static bfd_boolean
12789 is_32bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12790 {
12791 /* Please keep this table alpha-sorted for ease of visual lookup. */
12792 switch (filedata->file_header.e_machine)
12793 {
12794 case EM_RISCV:
12795 return reloc_type == 39; /* R_RISCV_SUB32. */
12796 default:
12797 return FALSE;
12798 }
12799 }
12800
12801 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12802 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
12803
12804 static bfd_boolean
12805 is_64bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12806 {
12807 /* Please keep this table alpha-sorted for ease of visual lookup. */
12808 switch (filedata->file_header.e_machine)
12809 {
12810 case EM_RISCV:
12811 return reloc_type == 36; /* R_RISCV_ADD64. */
12812 default:
12813 return FALSE;
12814 }
12815 }
12816
12817 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12818 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
12819
12820 static bfd_boolean
12821 is_64bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12822 {
12823 /* Please keep this table alpha-sorted for ease of visual lookup. */
12824 switch (filedata->file_header.e_machine)
12825 {
12826 case EM_RISCV:
12827 return reloc_type == 40; /* R_RISCV_SUB64. */
12828 default:
12829 return FALSE;
12830 }
12831 }
12832
12833 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12834 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
12835
12836 static bfd_boolean
12837 is_16bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12838 {
12839 /* Please keep this table alpha-sorted for ease of visual lookup. */
12840 switch (filedata->file_header.e_machine)
12841 {
12842 case EM_RISCV:
12843 return reloc_type == 34; /* R_RISCV_ADD16. */
12844 default:
12845 return FALSE;
12846 }
12847 }
12848
12849 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12850 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
12851
12852 static bfd_boolean
12853 is_16bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12854 {
12855 /* Please keep this table alpha-sorted for ease of visual lookup. */
12856 switch (filedata->file_header.e_machine)
12857 {
12858 case EM_RISCV:
12859 return reloc_type == 38; /* R_RISCV_SUB16. */
12860 default:
12861 return FALSE;
12862 }
12863 }
12864
12865 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12866 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
12867
12868 static bfd_boolean
12869 is_8bit_inplace_add_reloc (Filedata * filedata, unsigned int reloc_type)
12870 {
12871 /* Please keep this table alpha-sorted for ease of visual lookup. */
12872 switch (filedata->file_header.e_machine)
12873 {
12874 case EM_RISCV:
12875 return reloc_type == 33; /* R_RISCV_ADD8. */
12876 default:
12877 return FALSE;
12878 }
12879 }
12880
12881 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12882 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
12883
12884 static bfd_boolean
12885 is_8bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12886 {
12887 /* Please keep this table alpha-sorted for ease of visual lookup. */
12888 switch (filedata->file_header.e_machine)
12889 {
12890 case EM_RISCV:
12891 return reloc_type == 37; /* R_RISCV_SUB8. */
12892 default:
12893 return FALSE;
12894 }
12895 }
12896
12897 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12898 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
12899
12900 static bfd_boolean
12901 is_6bit_inplace_sub_reloc (Filedata * filedata, unsigned int reloc_type)
12902 {
12903 switch (filedata->file_header.e_machine)
12904 {
12905 case EM_RISCV:
12906 return reloc_type == 52; /* R_RISCV_SUB6. */
12907 default:
12908 return FALSE;
12909 }
12910 }
12911
12912 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12913 relocation entries (possibly formerly used for SHT_GROUP sections). */
12914
12915 static bfd_boolean
12916 is_none_reloc (Filedata * filedata, unsigned int reloc_type)
12917 {
12918 switch (filedata->file_header.e_machine)
12919 {
12920 case EM_386: /* R_386_NONE. */
12921 case EM_68K: /* R_68K_NONE. */
12922 case EM_ADAPTEVA_EPIPHANY:
12923 case EM_ALPHA: /* R_ALPHA_NONE. */
12924 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
12925 case EM_ARC: /* R_ARC_NONE. */
12926 case EM_ARC_COMPACT2: /* R_ARC_NONE. */
12927 case EM_ARC_COMPACT: /* R_ARC_NONE. */
12928 case EM_ARM: /* R_ARM_NONE. */
12929 case EM_C166: /* R_XC16X_NONE. */
12930 case EM_CRIS: /* R_CRIS_NONE. */
12931 case EM_FT32: /* R_FT32_NONE. */
12932 case EM_IA_64: /* R_IA64_NONE. */
12933 case EM_K1OM: /* R_X86_64_NONE. */
12934 case EM_L1OM: /* R_X86_64_NONE. */
12935 case EM_M32R: /* R_M32R_NONE. */
12936 case EM_MIPS: /* R_MIPS_NONE. */
12937 case EM_MN10300: /* R_MN10300_NONE. */
12938 case EM_MOXIE: /* R_MOXIE_NONE. */
12939 case EM_NIOS32: /* R_NIOS_NONE. */
12940 case EM_OR1K: /* R_OR1K_NONE. */
12941 case EM_PARISC: /* R_PARISC_NONE. */
12942 case EM_PPC64: /* R_PPC64_NONE. */
12943 case EM_PPC: /* R_PPC_NONE. */
12944 case EM_RISCV: /* R_RISCV_NONE. */
12945 case EM_S390: /* R_390_NONE. */
12946 case EM_S390_OLD:
12947 case EM_SH: /* R_SH_NONE. */
12948 case EM_SPARC32PLUS:
12949 case EM_SPARC: /* R_SPARC_NONE. */
12950 case EM_SPARCV9:
12951 case EM_TILEGX: /* R_TILEGX_NONE. */
12952 case EM_TILEPRO: /* R_TILEPRO_NONE. */
12953 case EM_TI_C6000:/* R_C6000_NONE. */
12954 case EM_X86_64: /* R_X86_64_NONE. */
12955 case EM_XC16X:
12956 case EM_WEBASSEMBLY: /* R_WASM32_NONE. */
12957 return reloc_type == 0;
12958
12959 case EM_AARCH64:
12960 return reloc_type == 0 || reloc_type == 256;
12961 case EM_AVR_OLD:
12962 case EM_AVR:
12963 return (reloc_type == 0 /* R_AVR_NONE. */
12964 || reloc_type == 30 /* R_AVR_DIFF8. */
12965 || reloc_type == 31 /* R_AVR_DIFF16. */
12966 || reloc_type == 32 /* R_AVR_DIFF32. */);
12967 case EM_METAG:
12968 return reloc_type == 3; /* R_METAG_NONE. */
12969 case EM_NDS32:
12970 return (reloc_type == 0 /* R_XTENSA_NONE. */
12971 || reloc_type == 204 /* R_NDS32_DIFF8. */
12972 || reloc_type == 205 /* R_NDS32_DIFF16. */
12973 || reloc_type == 206 /* R_NDS32_DIFF32. */
12974 || reloc_type == 207 /* R_NDS32_ULEB128. */);
12975 case EM_TI_PRU:
12976 return (reloc_type == 0 /* R_PRU_NONE. */
12977 || reloc_type == 65 /* R_PRU_DIFF8. */
12978 || reloc_type == 66 /* R_PRU_DIFF16. */
12979 || reloc_type == 67 /* R_PRU_DIFF32. */);
12980 case EM_XTENSA_OLD:
12981 case EM_XTENSA:
12982 return (reloc_type == 0 /* R_XTENSA_NONE. */
12983 || reloc_type == 17 /* R_XTENSA_DIFF8. */
12984 || reloc_type == 18 /* R_XTENSA_DIFF16. */
12985 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
12986 }
12987 return FALSE;
12988 }
12989
12990 /* Returns TRUE if there is a relocation against
12991 section NAME at OFFSET bytes. */
12992
12993 bfd_boolean
12994 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
12995 {
12996 Elf_Internal_Rela * relocs;
12997 Elf_Internal_Rela * rp;
12998
12999 if (dsec == NULL || dsec->reloc_info == NULL)
13000 return FALSE;
13001
13002 relocs = (Elf_Internal_Rela *) dsec->reloc_info;
13003
13004 for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
13005 if (rp->r_offset == offset)
13006 return TRUE;
13007
13008 return FALSE;
13009 }
13010
13011 /* Apply relocations to a section.
13012 Returns TRUE upon success, FALSE otherwise.
13013 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13014 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13015 will be set to the number of relocs loaded.
13016
13017 Note: So far support has been added only for those relocations
13018 which can be found in debug sections. FIXME: Add support for
13019 more relocations ? */
13020
13021 static bfd_boolean
13022 apply_relocations (Filedata * filedata,
13023 const Elf_Internal_Shdr * section,
13024 unsigned char * start,
13025 bfd_size_type size,
13026 void ** relocs_return,
13027 unsigned long * num_relocs_return)
13028 {
13029 Elf_Internal_Shdr * relsec;
13030 unsigned char * end = start + size;
13031 bfd_boolean res = TRUE;
13032
13033 if (relocs_return != NULL)
13034 {
13035 * (Elf_Internal_Rela **) relocs_return = NULL;
13036 * num_relocs_return = 0;
13037 }
13038
13039 if (filedata->file_header.e_type != ET_REL)
13040 /* No relocs to apply. */
13041 return TRUE;
13042
13043 /* Find the reloc section associated with the section. */
13044 for (relsec = filedata->section_headers;
13045 relsec < filedata->section_headers + filedata->file_header.e_shnum;
13046 ++relsec)
13047 {
13048 bfd_boolean is_rela;
13049 unsigned long num_relocs;
13050 Elf_Internal_Rela * relocs;
13051 Elf_Internal_Rela * rp;
13052 Elf_Internal_Shdr * symsec;
13053 Elf_Internal_Sym * symtab;
13054 unsigned long num_syms;
13055 Elf_Internal_Sym * sym;
13056
13057 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13058 || relsec->sh_info >= filedata->file_header.e_shnum
13059 || filedata->section_headers + relsec->sh_info != section
13060 || relsec->sh_size == 0
13061 || relsec->sh_link >= filedata->file_header.e_shnum)
13062 continue;
13063
13064 is_rela = relsec->sh_type == SHT_RELA;
13065
13066 if (is_rela)
13067 {
13068 if (!slurp_rela_relocs (filedata, relsec->sh_offset,
13069 relsec->sh_size, & relocs, & num_relocs))
13070 return FALSE;
13071 }
13072 else
13073 {
13074 if (!slurp_rel_relocs (filedata, relsec->sh_offset,
13075 relsec->sh_size, & relocs, & num_relocs))
13076 return FALSE;
13077 }
13078
13079 /* SH uses RELA but uses in place value instead of the addend field. */
13080 if (filedata->file_header.e_machine == EM_SH)
13081 is_rela = FALSE;
13082
13083 symsec = filedata->section_headers + relsec->sh_link;
13084 if (symsec->sh_type != SHT_SYMTAB
13085 && symsec->sh_type != SHT_DYNSYM)
13086 return FALSE;
13087 symtab = GET_ELF_SYMBOLS (filedata, symsec, & num_syms);
13088
13089 for (rp = relocs; rp < relocs + num_relocs; ++rp)
13090 {
13091 bfd_vma addend;
13092 unsigned int reloc_type;
13093 unsigned int reloc_size;
13094 bfd_boolean reloc_inplace = FALSE;
13095 bfd_boolean reloc_subtract = FALSE;
13096 unsigned char * rloc;
13097 unsigned long sym_index;
13098
13099 reloc_type = get_reloc_type (filedata, rp->r_info);
13100
13101 if (target_specific_reloc_handling (filedata, rp, start, end, symtab, num_syms))
13102 continue;
13103 else if (is_none_reloc (filedata, reloc_type))
13104 continue;
13105 else if (is_32bit_abs_reloc (filedata, reloc_type)
13106 || is_32bit_pcrel_reloc (filedata, reloc_type))
13107 reloc_size = 4;
13108 else if (is_64bit_abs_reloc (filedata, reloc_type)
13109 || is_64bit_pcrel_reloc (filedata, reloc_type))
13110 reloc_size = 8;
13111 else if (is_24bit_abs_reloc (filedata, reloc_type))
13112 reloc_size = 3;
13113 else if (is_16bit_abs_reloc (filedata, reloc_type))
13114 reloc_size = 2;
13115 else if (is_8bit_abs_reloc (filedata, reloc_type)
13116 || is_6bit_abs_reloc (filedata, reloc_type))
13117 reloc_size = 1;
13118 else if ((reloc_subtract = is_32bit_inplace_sub_reloc (filedata,
13119 reloc_type))
13120 || is_32bit_inplace_add_reloc (filedata, reloc_type))
13121 {
13122 reloc_size = 4;
13123 reloc_inplace = TRUE;
13124 }
13125 else if ((reloc_subtract = is_64bit_inplace_sub_reloc (filedata,
13126 reloc_type))
13127 || is_64bit_inplace_add_reloc (filedata, reloc_type))
13128 {
13129 reloc_size = 8;
13130 reloc_inplace = TRUE;
13131 }
13132 else if ((reloc_subtract = is_16bit_inplace_sub_reloc (filedata,
13133 reloc_type))
13134 || is_16bit_inplace_add_reloc (filedata, reloc_type))
13135 {
13136 reloc_size = 2;
13137 reloc_inplace = TRUE;
13138 }
13139 else if ((reloc_subtract = is_8bit_inplace_sub_reloc (filedata,
13140 reloc_type))
13141 || is_8bit_inplace_add_reloc (filedata, reloc_type))
13142 {
13143 reloc_size = 1;
13144 reloc_inplace = TRUE;
13145 }
13146 else if ((reloc_subtract = is_6bit_inplace_sub_reloc (filedata,
13147 reloc_type)))
13148 {
13149 reloc_size = 1;
13150 reloc_inplace = TRUE;
13151 }
13152 else
13153 {
13154 static unsigned int prev_reloc = 0;
13155
13156 if (reloc_type != prev_reloc)
13157 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13158 reloc_type, printable_section_name (filedata, section));
13159 prev_reloc = reloc_type;
13160 res = FALSE;
13161 continue;
13162 }
13163
13164 rloc = start + rp->r_offset;
13165 if ((rloc + reloc_size) > end || (rloc < start))
13166 {
13167 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13168 (unsigned long) rp->r_offset,
13169 printable_section_name (filedata, section));
13170 res = FALSE;
13171 continue;
13172 }
13173
13174 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
13175 if (sym_index >= num_syms)
13176 {
13177 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13178 sym_index, printable_section_name (filedata, section));
13179 res = FALSE;
13180 continue;
13181 }
13182 sym = symtab + sym_index;
13183
13184 /* If the reloc has a symbol associated with it,
13185 make sure that it is of an appropriate type.
13186
13187 Relocations against symbols without type can happen.
13188 Gcc -feliminate-dwarf2-dups may generate symbols
13189 without type for debug info.
13190
13191 Icc generates relocations against function symbols
13192 instead of local labels.
13193
13194 Relocations against object symbols can happen, eg when
13195 referencing a global array. For an example of this see
13196 the _clz.o binary in libgcc.a. */
13197 if (sym != symtab
13198 && ELF_ST_TYPE (sym->st_info) != STT_COMMON
13199 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
13200 {
13201 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13202 get_symbol_type (filedata, ELF_ST_TYPE (sym->st_info)),
13203 printable_section_name (filedata, relsec),
13204 (long int)(rp - relocs));
13205 res = FALSE;
13206 continue;
13207 }
13208
13209 addend = 0;
13210 if (is_rela)
13211 addend += rp->r_addend;
13212 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13213 partial_inplace. */
13214 if (!is_rela
13215 || (filedata->file_header.e_machine == EM_XTENSA
13216 && reloc_type == 1)
13217 || ((filedata->file_header.e_machine == EM_PJ
13218 || filedata->file_header.e_machine == EM_PJ_OLD)
13219 && reloc_type == 1)
13220 || ((filedata->file_header.e_machine == EM_D30V
13221 || filedata->file_header.e_machine == EM_CYGNUS_D30V)
13222 && reloc_type == 12)
13223 || reloc_inplace)
13224 {
13225 if (is_6bit_inplace_sub_reloc (filedata, reloc_type))
13226 addend += byte_get (rloc, reloc_size) & 0x3f;
13227 else
13228 addend += byte_get (rloc, reloc_size);
13229 }
13230
13231 if (is_32bit_pcrel_reloc (filedata, reloc_type)
13232 || is_64bit_pcrel_reloc (filedata, reloc_type))
13233 {
13234 /* On HPPA, all pc-relative relocations are biased by 8. */
13235 if (filedata->file_header.e_machine == EM_PARISC)
13236 addend -= 8;
13237 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
13238 reloc_size);
13239 }
13240 else if (is_6bit_abs_reloc (filedata, reloc_type)
13241 || is_6bit_inplace_sub_reloc (filedata, reloc_type))
13242 {
13243 if (reloc_subtract)
13244 addend -= sym->st_value;
13245 else
13246 addend += sym->st_value;
13247 addend = (addend & 0x3f) | (byte_get (rloc, reloc_size) & 0xc0);
13248 byte_put (rloc, addend, reloc_size);
13249 }
13250 else if (reloc_subtract)
13251 byte_put (rloc, addend - sym->st_value, reloc_size);
13252 else
13253 byte_put (rloc, addend + sym->st_value, reloc_size);
13254 }
13255
13256 free (symtab);
13257 /* Let the target specific reloc processing code know that
13258 we have finished with these relocs. */
13259 target_specific_reloc_handling (filedata, NULL, NULL, NULL, NULL, 0);
13260
13261 if (relocs_return)
13262 {
13263 * (Elf_Internal_Rela **) relocs_return = relocs;
13264 * num_relocs_return = num_relocs;
13265 }
13266 else
13267 free (relocs);
13268
13269 break;
13270 }
13271
13272 return res;
13273 }
13274
13275 #ifdef SUPPORT_DISASSEMBLY
13276 static bfd_boolean
13277 disassemble_section (Elf_Internal_Shdr * section, Filedata * filedata)
13278 {
13279 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata, section));
13280
13281 /* FIXME: XXX -- to be done --- XXX */
13282
13283 return TRUE;
13284 }
13285 #endif
13286
13287 /* Reads in the contents of SECTION from FILE, returning a pointer
13288 to a malloc'ed buffer or NULL if something went wrong. */
13289
13290 static char *
13291 get_section_contents (Elf_Internal_Shdr * section, Filedata * filedata)
13292 {
13293 bfd_size_type num_bytes = section->sh_size;
13294
13295 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
13296 {
13297 printf (_("Section '%s' has no data to dump.\n"),
13298 printable_section_name (filedata, section));
13299 return NULL;
13300 }
13301
13302 return (char *) get_data (NULL, filedata, section->sh_offset, 1, num_bytes,
13303 _("section contents"));
13304 }
13305
13306 /* Uncompresses a section that was compressed using zlib, in place. */
13307
13308 static bfd_boolean
13309 uncompress_section_contents (unsigned char ** buffer,
13310 dwarf_size_type uncompressed_size,
13311 dwarf_size_type * size)
13312 {
13313 dwarf_size_type compressed_size = *size;
13314 unsigned char * compressed_buffer = *buffer;
13315 unsigned char * uncompressed_buffer;
13316 z_stream strm;
13317 int rc;
13318
13319 /* It is possible the section consists of several compressed
13320 buffers concatenated together, so we uncompress in a loop. */
13321 /* PR 18313: The state field in the z_stream structure is supposed
13322 to be invisible to the user (ie us), but some compilers will
13323 still complain about it being used without initialisation. So
13324 we first zero the entire z_stream structure and then set the fields
13325 that we need. */
13326 memset (& strm, 0, sizeof strm);
13327 strm.avail_in = compressed_size;
13328 strm.next_in = (Bytef *) compressed_buffer;
13329 strm.avail_out = uncompressed_size;
13330 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
13331
13332 rc = inflateInit (& strm);
13333 while (strm.avail_in > 0)
13334 {
13335 if (rc != Z_OK)
13336 goto fail;
13337 strm.next_out = ((Bytef *) uncompressed_buffer
13338 + (uncompressed_size - strm.avail_out));
13339 rc = inflate (&strm, Z_FINISH);
13340 if (rc != Z_STREAM_END)
13341 goto fail;
13342 rc = inflateReset (& strm);
13343 }
13344 rc = inflateEnd (& strm);
13345 if (rc != Z_OK
13346 || strm.avail_out != 0)
13347 goto fail;
13348
13349 *buffer = uncompressed_buffer;
13350 *size = uncompressed_size;
13351 return TRUE;
13352
13353 fail:
13354 free (uncompressed_buffer);
13355 /* Indicate decompression failure. */
13356 *buffer = NULL;
13357 return FALSE;
13358 }
13359
13360 static bfd_boolean
13361 dump_section_as_strings (Elf_Internal_Shdr * section, Filedata * filedata)
13362 {
13363 Elf_Internal_Shdr * relsec;
13364 bfd_size_type num_bytes;
13365 unsigned char * data;
13366 unsigned char * end;
13367 unsigned char * real_start;
13368 unsigned char * start;
13369 bfd_boolean some_strings_shown;
13370
13371 real_start = start = (unsigned char *) get_section_contents (section, filedata);
13372 if (start == NULL)
13373 /* PR 21820: Do not fail if the section was empty. */
13374 return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13375
13376 num_bytes = section->sh_size;
13377
13378 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata, section));
13379
13380 if (decompress_dumps)
13381 {
13382 dwarf_size_type new_size = num_bytes;
13383 dwarf_size_type uncompressed_size = 0;
13384
13385 if ((section->sh_flags & SHF_COMPRESSED) != 0)
13386 {
13387 Elf_Internal_Chdr chdr;
13388 unsigned int compression_header_size
13389 = get_compression_header (& chdr, (unsigned char *) start,
13390 num_bytes);
13391
13392 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13393 {
13394 warn (_("section '%s' has unsupported compress type: %d\n"),
13395 printable_section_name (filedata, section), chdr.ch_type);
13396 return FALSE;
13397 }
13398 else if (chdr.ch_addralign != section->sh_addralign)
13399 {
13400 warn (_("compressed section '%s' is corrupted\n"),
13401 printable_section_name (filedata, section));
13402 return FALSE;
13403 }
13404 uncompressed_size = chdr.ch_size;
13405 start += compression_header_size;
13406 new_size -= compression_header_size;
13407 }
13408 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13409 {
13410 /* Read the zlib header. In this case, it should be "ZLIB"
13411 followed by the uncompressed section size, 8 bytes in
13412 big-endian order. */
13413 uncompressed_size = start[4]; uncompressed_size <<= 8;
13414 uncompressed_size += start[5]; uncompressed_size <<= 8;
13415 uncompressed_size += start[6]; uncompressed_size <<= 8;
13416 uncompressed_size += start[7]; uncompressed_size <<= 8;
13417 uncompressed_size += start[8]; uncompressed_size <<= 8;
13418 uncompressed_size += start[9]; uncompressed_size <<= 8;
13419 uncompressed_size += start[10]; uncompressed_size <<= 8;
13420 uncompressed_size += start[11];
13421 start += 12;
13422 new_size -= 12;
13423 }
13424
13425 if (uncompressed_size)
13426 {
13427 if (uncompress_section_contents (& start,
13428 uncompressed_size, & new_size))
13429 num_bytes = new_size;
13430 else
13431 {
13432 error (_("Unable to decompress section %s\n"),
13433 printable_section_name (filedata, section));
13434 return FALSE;
13435 }
13436 }
13437 else
13438 start = real_start;
13439 }
13440
13441 /* If the section being dumped has relocations against it the user might
13442 be expecting these relocations to have been applied. Check for this
13443 case and issue a warning message in order to avoid confusion.
13444 FIXME: Maybe we ought to have an option that dumps a section with
13445 relocs applied ? */
13446 for (relsec = filedata->section_headers;
13447 relsec < filedata->section_headers + filedata->file_header.e_shnum;
13448 ++relsec)
13449 {
13450 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13451 || relsec->sh_info >= filedata->file_header.e_shnum
13452 || filedata->section_headers + relsec->sh_info != section
13453 || relsec->sh_size == 0
13454 || relsec->sh_link >= filedata->file_header.e_shnum)
13455 continue;
13456
13457 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13458 break;
13459 }
13460
13461 data = start;
13462 end = start + num_bytes;
13463 some_strings_shown = FALSE;
13464
13465 while (data < end)
13466 {
13467 while (!ISPRINT (* data))
13468 if (++ data >= end)
13469 break;
13470
13471 if (data < end)
13472 {
13473 size_t maxlen = end - data;
13474
13475 #ifndef __MSVCRT__
13476 /* PR 11128: Use two separate invocations in order to work
13477 around bugs in the Solaris 8 implementation of printf. */
13478 printf (" [%6tx] ", data - start);
13479 #else
13480 printf (" [%6Ix] ", (size_t) (data - start));
13481 #endif
13482 if (maxlen > 0)
13483 {
13484 print_symbol ((int) maxlen, (const char *) data);
13485 putchar ('\n');
13486 data += strnlen ((const char *) data, maxlen);
13487 }
13488 else
13489 {
13490 printf (_("<corrupt>\n"));
13491 data = end;
13492 }
13493 some_strings_shown = TRUE;
13494 }
13495 }
13496
13497 if (! some_strings_shown)
13498 printf (_(" No strings found in this section."));
13499
13500 free (real_start);
13501
13502 putchar ('\n');
13503 return TRUE;
13504 }
13505
13506 static bfd_boolean
13507 dump_section_as_bytes (Elf_Internal_Shdr * section,
13508 Filedata * filedata,
13509 bfd_boolean relocate)
13510 {
13511 Elf_Internal_Shdr * relsec;
13512 bfd_size_type bytes;
13513 bfd_size_type section_size;
13514 bfd_vma addr;
13515 unsigned char * data;
13516 unsigned char * real_start;
13517 unsigned char * start;
13518
13519 real_start = start = (unsigned char *) get_section_contents (section, filedata);
13520 if (start == NULL)
13521 /* PR 21820: Do not fail if the section was empty. */
13522 return (section->sh_size == 0 || section->sh_type == SHT_NOBITS) ? TRUE : FALSE;
13523
13524 section_size = section->sh_size;
13525
13526 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata, section));
13527
13528 if (decompress_dumps)
13529 {
13530 dwarf_size_type new_size = section_size;
13531 dwarf_size_type uncompressed_size = 0;
13532
13533 if ((section->sh_flags & SHF_COMPRESSED) != 0)
13534 {
13535 Elf_Internal_Chdr chdr;
13536 unsigned int compression_header_size
13537 = get_compression_header (& chdr, start, section_size);
13538
13539 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13540 {
13541 warn (_("section '%s' has unsupported compress type: %d\n"),
13542 printable_section_name (filedata, section), chdr.ch_type);
13543 return FALSE;
13544 }
13545 else if (chdr.ch_addralign != section->sh_addralign)
13546 {
13547 warn (_("compressed section '%s' is corrupted\n"),
13548 printable_section_name (filedata, section));
13549 return FALSE;
13550 }
13551 uncompressed_size = chdr.ch_size;
13552 start += compression_header_size;
13553 new_size -= compression_header_size;
13554 }
13555 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
13556 {
13557 /* Read the zlib header. In this case, it should be "ZLIB"
13558 followed by the uncompressed section size, 8 bytes in
13559 big-endian order. */
13560 uncompressed_size = start[4]; uncompressed_size <<= 8;
13561 uncompressed_size += start[5]; uncompressed_size <<= 8;
13562 uncompressed_size += start[6]; uncompressed_size <<= 8;
13563 uncompressed_size += start[7]; uncompressed_size <<= 8;
13564 uncompressed_size += start[8]; uncompressed_size <<= 8;
13565 uncompressed_size += start[9]; uncompressed_size <<= 8;
13566 uncompressed_size += start[10]; uncompressed_size <<= 8;
13567 uncompressed_size += start[11];
13568 start += 12;
13569 new_size -= 12;
13570 }
13571
13572 if (uncompressed_size)
13573 {
13574 if (uncompress_section_contents (& start, uncompressed_size,
13575 & new_size))
13576 {
13577 section_size = new_size;
13578 }
13579 else
13580 {
13581 error (_("Unable to decompress section %s\n"),
13582 printable_section_name (filedata, section));
13583 /* FIXME: Print the section anyway ? */
13584 return FALSE;
13585 }
13586 }
13587 else
13588 start = real_start;
13589 }
13590
13591 if (relocate)
13592 {
13593 if (! apply_relocations (filedata, section, start, section_size, NULL, NULL))
13594 return FALSE;
13595 }
13596 else
13597 {
13598 /* If the section being dumped has relocations against it the user might
13599 be expecting these relocations to have been applied. Check for this
13600 case and issue a warning message in order to avoid confusion.
13601 FIXME: Maybe we ought to have an option that dumps a section with
13602 relocs applied ? */
13603 for (relsec = filedata->section_headers;
13604 relsec < filedata->section_headers + filedata->file_header.e_shnum;
13605 ++relsec)
13606 {
13607 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
13608 || relsec->sh_info >= filedata->file_header.e_shnum
13609 || filedata->section_headers + relsec->sh_info != section
13610 || relsec->sh_size == 0
13611 || relsec->sh_link >= filedata->file_header.e_shnum)
13612 continue;
13613
13614 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13615 break;
13616 }
13617 }
13618
13619 addr = section->sh_addr;
13620 bytes = section_size;
13621 data = start;
13622
13623 while (bytes)
13624 {
13625 int j;
13626 int k;
13627 int lbytes;
13628
13629 lbytes = (bytes > 16 ? 16 : bytes);
13630
13631 printf (" 0x%8.8lx ", (unsigned long) addr);
13632
13633 for (j = 0; j < 16; j++)
13634 {
13635 if (j < lbytes)
13636 printf ("%2.2x", data[j]);
13637 else
13638 printf (" ");
13639
13640 if ((j & 3) == 3)
13641 printf (" ");
13642 }
13643
13644 for (j = 0; j < lbytes; j++)
13645 {
13646 k = data[j];
13647 if (k >= ' ' && k < 0x7f)
13648 printf ("%c", k);
13649 else
13650 printf (".");
13651 }
13652
13653 putchar ('\n');
13654
13655 data += lbytes;
13656 addr += lbytes;
13657 bytes -= lbytes;
13658 }
13659
13660 free (real_start);
13661
13662 putchar ('\n');
13663 return TRUE;
13664 }
13665
13666 static bfd_boolean
13667 load_specific_debug_section (enum dwarf_section_display_enum debug,
13668 const Elf_Internal_Shdr * sec,
13669 void * data)
13670 {
13671 struct dwarf_section * section = &debug_displays [debug].section;
13672 char buf [64];
13673 Filedata * filedata = (Filedata *) data;
13674
13675 if (section->start != NULL)
13676 {
13677 /* If it is already loaded, do nothing. */
13678 if (streq (section->filename, filedata->file_name))
13679 return TRUE;
13680 free (section->start);
13681 }
13682
13683 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
13684 section->address = sec->sh_addr;
13685 section->user_data = NULL;
13686 section->filename = filedata->file_name;
13687 section->start = (unsigned char *) get_data (NULL, filedata,
13688 sec->sh_offset, 1,
13689 sec->sh_size, buf);
13690 if (section->start == NULL)
13691 section->size = 0;
13692 else
13693 {
13694 unsigned char *start = section->start;
13695 dwarf_size_type size = sec->sh_size;
13696 dwarf_size_type uncompressed_size = 0;
13697
13698 if ((sec->sh_flags & SHF_COMPRESSED) != 0)
13699 {
13700 Elf_Internal_Chdr chdr;
13701 unsigned int compression_header_size;
13702
13703 if (size < (is_32bit_elf
13704 ? sizeof (Elf32_External_Chdr)
13705 : sizeof (Elf64_External_Chdr)))
13706 {
13707 warn (_("compressed section %s is too small to contain a compression header"),
13708 section->name);
13709 return FALSE;
13710 }
13711
13712 compression_header_size = get_compression_header (&chdr, start, size);
13713
13714 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13715 {
13716 warn (_("section '%s' has unsupported compress type: %d\n"),
13717 section->name, chdr.ch_type);
13718 return FALSE;
13719 }
13720 else if (chdr.ch_addralign != sec->sh_addralign)
13721 {
13722 warn (_("compressed section '%s' is corrupted\n"),
13723 section->name);
13724 return FALSE;
13725 }
13726 uncompressed_size = chdr.ch_size;
13727 start += compression_header_size;
13728 size -= compression_header_size;
13729 }
13730 else if (size > 12 && streq ((char *) start, "ZLIB"))
13731 {
13732 /* Read the zlib header. In this case, it should be "ZLIB"
13733 followed by the uncompressed section size, 8 bytes in
13734 big-endian order. */
13735 uncompressed_size = start[4]; uncompressed_size <<= 8;
13736 uncompressed_size += start[5]; uncompressed_size <<= 8;
13737 uncompressed_size += start[6]; uncompressed_size <<= 8;
13738 uncompressed_size += start[7]; uncompressed_size <<= 8;
13739 uncompressed_size += start[8]; uncompressed_size <<= 8;
13740 uncompressed_size += start[9]; uncompressed_size <<= 8;
13741 uncompressed_size += start[10]; uncompressed_size <<= 8;
13742 uncompressed_size += start[11];
13743 start += 12;
13744 size -= 12;
13745 }
13746
13747 if (uncompressed_size)
13748 {
13749 if (uncompress_section_contents (&start, uncompressed_size,
13750 &size))
13751 {
13752 /* Free the compressed buffer, update the section buffer
13753 and the section size if uncompress is successful. */
13754 free (section->start);
13755 section->start = start;
13756 }
13757 else
13758 {
13759 error (_("Unable to decompress section %s\n"),
13760 printable_section_name (filedata, sec));
13761 return FALSE;
13762 }
13763 }
13764
13765 section->size = size;
13766 }
13767
13768 if (section->start == NULL)
13769 return FALSE;
13770
13771 if (debug_displays [debug].relocate)
13772 {
13773 if (! apply_relocations (filedata, sec, section->start, section->size,
13774 & section->reloc_info, & section->num_relocs))
13775 return FALSE;
13776 }
13777 else
13778 {
13779 section->reloc_info = NULL;
13780 section->num_relocs = 0;
13781 }
13782
13783 return TRUE;
13784 }
13785
13786 /* If this is not NULL, load_debug_section will only look for sections
13787 within the list of sections given here. */
13788 static unsigned int * section_subset = NULL;
13789
13790 bfd_boolean
13791 load_debug_section (enum dwarf_section_display_enum debug, void * data)
13792 {
13793 struct dwarf_section * section = &debug_displays [debug].section;
13794 Elf_Internal_Shdr * sec;
13795 Filedata * filedata = (Filedata *) data;
13796
13797 /* Without section headers we cannot find any sections. */
13798 if (filedata->section_headers == NULL)
13799 return FALSE;
13800
13801 if (filedata->string_table == NULL
13802 && filedata->file_header.e_shstrndx != SHN_UNDEF
13803 && filedata->file_header.e_shstrndx < filedata->file_header.e_shnum)
13804 {
13805 Elf_Internal_Shdr * strs;
13806
13807 /* Read in the string table, so that we have section names to scan. */
13808 strs = filedata->section_headers + filedata->file_header.e_shstrndx;
13809
13810 if (strs != NULL && strs->sh_size != 0)
13811 {
13812 filedata->string_table
13813 = (char *) get_data (NULL, filedata, strs->sh_offset,
13814 1, strs->sh_size, _("string table"));
13815
13816 filedata->string_table_length
13817 = filedata->string_table != NULL ? strs->sh_size : 0;
13818 }
13819 }
13820
13821 /* Locate the debug section. */
13822 sec = find_section_in_set (filedata, section->uncompressed_name, section_subset);
13823 if (sec != NULL)
13824 section->name = section->uncompressed_name;
13825 else
13826 {
13827 sec = find_section_in_set (filedata, section->compressed_name, section_subset);
13828 if (sec != NULL)
13829 section->name = section->compressed_name;
13830 }
13831 if (sec == NULL)
13832 return FALSE;
13833
13834 /* If we're loading from a subset of sections, and we've loaded
13835 a section matching this name before, it's likely that it's a
13836 different one. */
13837 if (section_subset != NULL)
13838 free_debug_section (debug);
13839
13840 return load_specific_debug_section (debug, sec, data);
13841 }
13842
13843 void
13844 free_debug_section (enum dwarf_section_display_enum debug)
13845 {
13846 struct dwarf_section * section = &debug_displays [debug].section;
13847
13848 if (section->start == NULL)
13849 return;
13850
13851 free ((char *) section->start);
13852 section->start = NULL;
13853 section->address = 0;
13854 section->size = 0;
13855 }
13856
13857 static bfd_boolean
13858 display_debug_section (int shndx, Elf_Internal_Shdr * section, Filedata * filedata)
13859 {
13860 char * name = SECTION_NAME (section);
13861 const char * print_name = printable_section_name (filedata, section);
13862 bfd_size_type length;
13863 bfd_boolean result = TRUE;
13864 int i;
13865
13866 length = section->sh_size;
13867 if (length == 0)
13868 {
13869 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
13870 return TRUE;
13871 }
13872 if (section->sh_type == SHT_NOBITS)
13873 {
13874 /* There is no point in dumping the contents of a debugging section
13875 which has the NOBITS type - the bits in the file will be random.
13876 This can happen when a file containing a .eh_frame section is
13877 stripped with the --only-keep-debug command line option. */
13878 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13879 print_name);
13880 return FALSE;
13881 }
13882
13883 if (const_strneq (name, ".gnu.linkonce.wi."))
13884 name = ".debug_info";
13885
13886 /* See if we know how to display the contents of this section. */
13887 for (i = 0; i < max; i++)
13888 {
13889 enum dwarf_section_display_enum id = (enum dwarf_section_display_enum) i;
13890 struct dwarf_section_display * display = debug_displays + i;
13891 struct dwarf_section * sec = & display->section;
13892
13893 if (streq (sec->uncompressed_name, name)
13894 || (id == line && const_strneq (name, ".debug_line."))
13895 || streq (sec->compressed_name, name))
13896 {
13897 bfd_boolean secondary = (section != find_section (filedata, name));
13898
13899 if (secondary)
13900 free_debug_section (id);
13901
13902 if (i == line && const_strneq (name, ".debug_line."))
13903 sec->name = name;
13904 else if (streq (sec->uncompressed_name, name))
13905 sec->name = sec->uncompressed_name;
13906 else
13907 sec->name = sec->compressed_name;
13908
13909 if (load_specific_debug_section (id, section, filedata))
13910 {
13911 /* If this debug section is part of a CU/TU set in a .dwp file,
13912 restrict load_debug_section to the sections in that set. */
13913 section_subset = find_cu_tu_set (filedata, shndx);
13914
13915 result &= display->display (sec, filedata);
13916
13917 section_subset = NULL;
13918
13919 if (secondary || (id != info && id != abbrev))
13920 free_debug_section (id);
13921 }
13922 break;
13923 }
13924 }
13925
13926 if (i == max)
13927 {
13928 printf (_("Unrecognized debug section: %s\n"), print_name);
13929 result = FALSE;
13930 }
13931
13932 return result;
13933 }
13934
13935 /* Set DUMP_SECTS for all sections where dumps were requested
13936 based on section name. */
13937
13938 static void
13939 initialise_dumps_byname (Filedata * filedata)
13940 {
13941 struct dump_list_entry * cur;
13942
13943 for (cur = dump_sects_byname; cur; cur = cur->next)
13944 {
13945 unsigned int i;
13946 bfd_boolean any = FALSE;
13947
13948 for (i = 0; i < filedata->file_header.e_shnum; i++)
13949 if (streq (SECTION_NAME (filedata->section_headers + i), cur->name))
13950 {
13951 request_dump_bynumber (filedata, i, cur->type);
13952 any = TRUE;
13953 }
13954
13955 if (!any)
13956 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13957 cur->name);
13958 }
13959 }
13960
13961 static bfd_boolean
13962 process_section_contents (Filedata * filedata)
13963 {
13964 Elf_Internal_Shdr * section;
13965 unsigned int i;
13966 bfd_boolean res = TRUE;
13967
13968 if (! do_dump)
13969 return TRUE;
13970
13971 initialise_dumps_byname (filedata);
13972
13973 for (i = 0, section = filedata->section_headers;
13974 i < filedata->file_header.e_shnum && i < filedata->num_dump_sects;
13975 i++, section++)
13976 {
13977 dump_type dump = filedata->dump_sects[i];
13978
13979 #ifdef SUPPORT_DISASSEMBLY
13980 if (dump & DISASS_DUMP)
13981 {
13982 if (! disassemble_section (section, filedata))
13983 res = FALSE;
13984 }
13985 #endif
13986 if (dump & HEX_DUMP)
13987 {
13988 if (! dump_section_as_bytes (section, filedata, FALSE))
13989 res = FALSE;
13990 }
13991
13992 if (dump & RELOC_DUMP)
13993 {
13994 if (! dump_section_as_bytes (section, filedata, TRUE))
13995 res = FALSE;
13996 }
13997
13998 if (dump & STRING_DUMP)
13999 {
14000 if (! dump_section_as_strings (section, filedata))
14001 res = FALSE;
14002 }
14003
14004 if (dump & DEBUG_DUMP)
14005 {
14006 if (! display_debug_section (i, section, filedata))
14007 res = FALSE;
14008 }
14009 }
14010
14011 /* Check to see if the user requested a
14012 dump of a section that does not exist. */
14013 while (i < filedata->num_dump_sects)
14014 {
14015 if (filedata->dump_sects[i])
14016 {
14017 warn (_("Section %d was not dumped because it does not exist!\n"), i);
14018 res = FALSE;
14019 }
14020 i++;
14021 }
14022
14023 return res;
14024 }
14025
14026 static void
14027 process_mips_fpe_exception (int mask)
14028 {
14029 if (mask)
14030 {
14031 bfd_boolean first = TRUE;
14032
14033 if (mask & OEX_FPU_INEX)
14034 fputs ("INEX", stdout), first = FALSE;
14035 if (mask & OEX_FPU_UFLO)
14036 printf ("%sUFLO", first ? "" : "|"), first = FALSE;
14037 if (mask & OEX_FPU_OFLO)
14038 printf ("%sOFLO", first ? "" : "|"), first = FALSE;
14039 if (mask & OEX_FPU_DIV0)
14040 printf ("%sDIV0", first ? "" : "|"), first = FALSE;
14041 if (mask & OEX_FPU_INVAL)
14042 printf ("%sINVAL", first ? "" : "|");
14043 }
14044 else
14045 fputs ("0", stdout);
14046 }
14047
14048 /* Display's the value of TAG at location P. If TAG is
14049 greater than 0 it is assumed to be an unknown tag, and
14050 a message is printed to this effect. Otherwise it is
14051 assumed that a message has already been printed.
14052
14053 If the bottom bit of TAG is set it assumed to have a
14054 string value, otherwise it is assumed to have an integer
14055 value.
14056
14057 Returns an updated P pointing to the first unread byte
14058 beyond the end of TAG's value.
14059
14060 Reads at or beyond END will not be made. */
14061
14062 static unsigned char *
14063 display_tag_value (signed int tag,
14064 unsigned char * p,
14065 const unsigned char * const end)
14066 {
14067 unsigned long val;
14068
14069 if (tag > 0)
14070 printf (" Tag_unknown_%d: ", tag);
14071
14072 if (p >= end)
14073 {
14074 warn (_("<corrupt tag>\n"));
14075 }
14076 else if (tag & 1)
14077 {
14078 /* PR 17531 file: 027-19978-0.004. */
14079 size_t maxlen = (end - p) - 1;
14080
14081 putchar ('"');
14082 if (maxlen > 0)
14083 {
14084 print_symbol ((int) maxlen, (const char *) p);
14085 p += strnlen ((char *) p, maxlen) + 1;
14086 }
14087 else
14088 {
14089 printf (_("<corrupt string tag>"));
14090 p = (unsigned char *) end;
14091 }
14092 printf ("\"\n");
14093 }
14094 else
14095 {
14096 unsigned int len;
14097
14098 val = read_uleb128 (p, &len, end);
14099 p += len;
14100 printf ("%ld (0x%lx)\n", val, val);
14101 }
14102
14103 assert (p <= end);
14104 return p;
14105 }
14106
14107 /* ARC ABI attributes section. */
14108
14109 static unsigned char *
14110 display_arc_attribute (unsigned char * p,
14111 const unsigned char * const end)
14112 {
14113 unsigned int tag;
14114 unsigned int len;
14115 unsigned int val;
14116
14117 tag = read_uleb128 (p, &len, end);
14118 p += len;
14119
14120 switch (tag)
14121 {
14122 case Tag_ARC_PCS_config:
14123 val = read_uleb128 (p, &len, end);
14124 p += len;
14125 printf (" Tag_ARC_PCS_config: ");
14126 switch (val)
14127 {
14128 case 0:
14129 printf (_("Absent/Non standard\n"));
14130 break;
14131 case 1:
14132 printf (_("Bare metal/mwdt\n"));
14133 break;
14134 case 2:
14135 printf (_("Bare metal/newlib\n"));
14136 break;
14137 case 3:
14138 printf (_("Linux/uclibc\n"));
14139 break;
14140 case 4:
14141 printf (_("Linux/glibc\n"));
14142 break;
14143 default:
14144 printf (_("Unknown\n"));
14145 break;
14146 }
14147 break;
14148
14149 case Tag_ARC_CPU_base:
14150 val = read_uleb128 (p, &len, end);
14151 p += len;
14152 printf (" Tag_ARC_CPU_base: ");
14153 switch (val)
14154 {
14155 default:
14156 case TAG_CPU_NONE:
14157 printf (_("Absent\n"));
14158 break;
14159 case TAG_CPU_ARC6xx:
14160 printf ("ARC6xx\n");
14161 break;
14162 case TAG_CPU_ARC7xx:
14163 printf ("ARC7xx\n");
14164 break;
14165 case TAG_CPU_ARCEM:
14166 printf ("ARCEM\n");
14167 break;
14168 case TAG_CPU_ARCHS:
14169 printf ("ARCHS\n");
14170 break;
14171 }
14172 break;
14173
14174 case Tag_ARC_CPU_variation:
14175 val = read_uleb128 (p, &len, end);
14176 p += len;
14177 printf (" Tag_ARC_CPU_variation: ");
14178 switch (val)
14179 {
14180 default:
14181 if (val > 0 && val < 16)
14182 printf ("Core%d\n", val);
14183 else
14184 printf ("Unknown\n");
14185 break;
14186
14187 case 0:
14188 printf (_("Absent\n"));
14189 break;
14190 }
14191 break;
14192
14193 case Tag_ARC_CPU_name:
14194 printf (" Tag_ARC_CPU_name: ");
14195 p = display_tag_value (-1, p, end);
14196 break;
14197
14198 case Tag_ARC_ABI_rf16:
14199 val = read_uleb128 (p, &len, end);
14200 p += len;
14201 printf (" Tag_ARC_ABI_rf16: %s\n", val ? _("yes") : _("no"));
14202 break;
14203
14204 case Tag_ARC_ABI_osver:
14205 val = read_uleb128 (p, &len, end);
14206 p += len;
14207 printf (" Tag_ARC_ABI_osver: v%d\n", val);
14208 break;
14209
14210 case Tag_ARC_ABI_pic:
14211 case Tag_ARC_ABI_sda:
14212 val = read_uleb128 (p, &len, end);
14213 p += len;
14214 printf (tag == Tag_ARC_ABI_sda ? " Tag_ARC_ABI_sda: "
14215 : " Tag_ARC_ABI_pic: ");
14216 switch (val)
14217 {
14218 case 0:
14219 printf (_("Absent\n"));
14220 break;
14221 case 1:
14222 printf ("MWDT\n");
14223 break;
14224 case 2:
14225 printf ("GNU\n");
14226 break;
14227 default:
14228 printf (_("Unknown\n"));
14229 break;
14230 }
14231 break;
14232
14233 case Tag_ARC_ABI_tls:
14234 val = read_uleb128 (p, &len, end);
14235 p += len;
14236 printf (" Tag_ARC_ABI_tls: %s\n", val ? "r25": "none");
14237 break;
14238
14239 case Tag_ARC_ABI_enumsize:
14240 val = read_uleb128 (p, &len, end);
14241 p += len;
14242 printf (" Tag_ARC_ABI_enumsize: %s\n", val ? _("default") :
14243 _("smallest"));
14244 break;
14245
14246 case Tag_ARC_ABI_exceptions:
14247 val = read_uleb128 (p, &len, end);
14248 p += len;
14249 printf (" Tag_ARC_ABI_exceptions: %s\n", val ? _("OPTFP")
14250 : _("default"));
14251 break;
14252
14253 case Tag_ARC_ABI_double_size:
14254 val = read_uleb128 (p, &len, end);
14255 p += len;
14256 printf (" Tag_ARC_ABI_double_size: %d\n", val);
14257 break;
14258
14259 case Tag_ARC_ISA_config:
14260 printf (" Tag_ARC_ISA_config: ");
14261 p = display_tag_value (-1, p, end);
14262 break;
14263
14264 case Tag_ARC_ISA_apex:
14265 printf (" Tag_ARC_ISA_apex: ");
14266 p = display_tag_value (-1, p, end);
14267 break;
14268
14269 case Tag_ARC_ISA_mpy_option:
14270 val = read_uleb128 (p, &len, end);
14271 p += len;
14272 printf (" Tag_ARC_ISA_mpy_option: %d\n", val);
14273 break;
14274
14275 case Tag_ARC_ATR_version:
14276 val = read_uleb128 (p, &len, end);
14277 p += len;
14278 printf (" Tag_ARC_ATR_version: %d\n", val);
14279 break;
14280
14281 default:
14282 return display_tag_value (tag & 1, p, end);
14283 }
14284
14285 return p;
14286 }
14287
14288 /* ARM EABI attributes section. */
14289 typedef struct
14290 {
14291 unsigned int tag;
14292 const char * name;
14293 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
14294 unsigned int type;
14295 const char ** table;
14296 } arm_attr_public_tag;
14297
14298 static const char * arm_attr_tag_CPU_arch[] =
14299 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14300 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14301 "v8-M.mainline"};
14302 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
14303 static const char * arm_attr_tag_THUMB_ISA_use[] =
14304 {"No", "Thumb-1", "Thumb-2", "Yes"};
14305 static const char * arm_attr_tag_FP_arch[] =
14306 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14307 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14308 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
14309 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
14310 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14311 "NEON for ARMv8.1"};
14312 static const char * arm_attr_tag_PCS_config[] =
14313 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14314 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14315 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
14316 {"V6", "SB", "TLS", "Unused"};
14317 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
14318 {"Absolute", "PC-relative", "SB-relative", "None"};
14319 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
14320 {"Absolute", "PC-relative", "None"};
14321 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
14322 {"None", "direct", "GOT-indirect"};
14323 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
14324 {"None", "??? 1", "2", "??? 3", "4"};
14325 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
14326 static const char * arm_attr_tag_ABI_FP_denormal[] =
14327 {"Unused", "Needed", "Sign only"};
14328 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
14329 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
14330 static const char * arm_attr_tag_ABI_FP_number_model[] =
14331 {"Unused", "Finite", "RTABI", "IEEE 754"};
14332 static const char * arm_attr_tag_ABI_enum_size[] =
14333 {"Unused", "small", "int", "forced to int"};
14334 static const char * arm_attr_tag_ABI_HardFP_use[] =
14335 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14336 static const char * arm_attr_tag_ABI_VFP_args[] =
14337 {"AAPCS", "VFP registers", "custom", "compatible"};
14338 static const char * arm_attr_tag_ABI_WMMX_args[] =
14339 {"AAPCS", "WMMX registers", "custom"};
14340 static const char * arm_attr_tag_ABI_optimization_goals[] =
14341 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14342 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14343 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
14344 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14345 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14346 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
14347 static const char * arm_attr_tag_FP_HP_extension[] =
14348 {"Not Allowed", "Allowed"};
14349 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
14350 {"None", "IEEE 754", "Alternative Format"};
14351 static const char * arm_attr_tag_DSP_extension[] =
14352 {"Follow architecture", "Allowed"};
14353 static const char * arm_attr_tag_MPextension_use[] =
14354 {"Not Allowed", "Allowed"};
14355 static const char * arm_attr_tag_DIV_use[] =
14356 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14357 "Allowed in v7-A with integer division extension"};
14358 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
14359 static const char * arm_attr_tag_Virtualization_use[] =
14360 {"Not Allowed", "TrustZone", "Virtualization Extensions",
14361 "TrustZone and Virtualization Extensions"};
14362 static const char * arm_attr_tag_MPextension_use_legacy[] =
14363 {"Not Allowed", "Allowed"};
14364
14365 #define LOOKUP(id, name) \
14366 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14367 static arm_attr_public_tag arm_attr_public_tags[] =
14368 {
14369 {4, "CPU_raw_name", 1, NULL},
14370 {5, "CPU_name", 1, NULL},
14371 LOOKUP(6, CPU_arch),
14372 {7, "CPU_arch_profile", 0, NULL},
14373 LOOKUP(8, ARM_ISA_use),
14374 LOOKUP(9, THUMB_ISA_use),
14375 LOOKUP(10, FP_arch),
14376 LOOKUP(11, WMMX_arch),
14377 LOOKUP(12, Advanced_SIMD_arch),
14378 LOOKUP(13, PCS_config),
14379 LOOKUP(14, ABI_PCS_R9_use),
14380 LOOKUP(15, ABI_PCS_RW_data),
14381 LOOKUP(16, ABI_PCS_RO_data),
14382 LOOKUP(17, ABI_PCS_GOT_use),
14383 LOOKUP(18, ABI_PCS_wchar_t),
14384 LOOKUP(19, ABI_FP_rounding),
14385 LOOKUP(20, ABI_FP_denormal),
14386 LOOKUP(21, ABI_FP_exceptions),
14387 LOOKUP(22, ABI_FP_user_exceptions),
14388 LOOKUP(23, ABI_FP_number_model),
14389 {24, "ABI_align_needed", 0, NULL},
14390 {25, "ABI_align_preserved", 0, NULL},
14391 LOOKUP(26, ABI_enum_size),
14392 LOOKUP(27, ABI_HardFP_use),
14393 LOOKUP(28, ABI_VFP_args),
14394 LOOKUP(29, ABI_WMMX_args),
14395 LOOKUP(30, ABI_optimization_goals),
14396 LOOKUP(31, ABI_FP_optimization_goals),
14397 {32, "compatibility", 0, NULL},
14398 LOOKUP(34, CPU_unaligned_access),
14399 LOOKUP(36, FP_HP_extension),
14400 LOOKUP(38, ABI_FP_16bit_format),
14401 LOOKUP(42, MPextension_use),
14402 LOOKUP(44, DIV_use),
14403 LOOKUP(46, DSP_extension),
14404 {64, "nodefaults", 0, NULL},
14405 {65, "also_compatible_with", 0, NULL},
14406 LOOKUP(66, T2EE_use),
14407 {67, "conformance", 1, NULL},
14408 LOOKUP(68, Virtualization_use),
14409 LOOKUP(70, MPextension_use_legacy)
14410 };
14411 #undef LOOKUP
14412
14413 static unsigned char *
14414 display_arm_attribute (unsigned char * p,
14415 const unsigned char * const end)
14416 {
14417 unsigned int tag;
14418 unsigned int len;
14419 unsigned int val;
14420 arm_attr_public_tag * attr;
14421 unsigned i;
14422 unsigned int type;
14423
14424 tag = read_uleb128 (p, &len, end);
14425 p += len;
14426 attr = NULL;
14427 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
14428 {
14429 if (arm_attr_public_tags[i].tag == tag)
14430 {
14431 attr = &arm_attr_public_tags[i];
14432 break;
14433 }
14434 }
14435
14436 if (attr)
14437 {
14438 printf (" Tag_%s: ", attr->name);
14439 switch (attr->type)
14440 {
14441 case 0:
14442 switch (tag)
14443 {
14444 case 7: /* Tag_CPU_arch_profile. */
14445 val = read_uleb128 (p, &len, end);
14446 p += len;
14447 switch (val)
14448 {
14449 case 0: printf (_("None\n")); break;
14450 case 'A': printf (_("Application\n")); break;
14451 case 'R': printf (_("Realtime\n")); break;
14452 case 'M': printf (_("Microcontroller\n")); break;
14453 case 'S': printf (_("Application or Realtime\n")); break;
14454 default: printf ("??? (%d)\n", val); break;
14455 }
14456 break;
14457
14458 case 24: /* Tag_align_needed. */
14459 val = read_uleb128 (p, &len, end);
14460 p += len;
14461 switch (val)
14462 {
14463 case 0: printf (_("None\n")); break;
14464 case 1: printf (_("8-byte\n")); break;
14465 case 2: printf (_("4-byte\n")); break;
14466 case 3: printf ("??? 3\n"); break;
14467 default:
14468 if (val <= 12)
14469 printf (_("8-byte and up to %d-byte extended\n"),
14470 1 << val);
14471 else
14472 printf ("??? (%d)\n", val);
14473 break;
14474 }
14475 break;
14476
14477 case 25: /* Tag_align_preserved. */
14478 val = read_uleb128 (p, &len, end);
14479 p += len;
14480 switch (val)
14481 {
14482 case 0: printf (_("None\n")); break;
14483 case 1: printf (_("8-byte, except leaf SP\n")); break;
14484 case 2: printf (_("8-byte\n")); break;
14485 case 3: printf ("??? 3\n"); break;
14486 default:
14487 if (val <= 12)
14488 printf (_("8-byte and up to %d-byte extended\n"),
14489 1 << val);
14490 else
14491 printf ("??? (%d)\n", val);
14492 break;
14493 }
14494 break;
14495
14496 case 32: /* Tag_compatibility. */
14497 {
14498 val = read_uleb128 (p, &len, end);
14499 p += len;
14500 printf (_("flag = %d, vendor = "), val);
14501 if (p < end - 1)
14502 {
14503 size_t maxlen = (end - p) - 1;
14504
14505 print_symbol ((int) maxlen, (const char *) p);
14506 p += strnlen ((char *) p, maxlen) + 1;
14507 }
14508 else
14509 {
14510 printf (_("<corrupt>"));
14511 p = (unsigned char *) end;
14512 }
14513 putchar ('\n');
14514 }
14515 break;
14516
14517 case 64: /* Tag_nodefaults. */
14518 /* PR 17531: file: 001-505008-0.01. */
14519 if (p < end)
14520 p++;
14521 printf (_("True\n"));
14522 break;
14523
14524 case 65: /* Tag_also_compatible_with. */
14525 val = read_uleb128 (p, &len, end);
14526 p += len;
14527 if (val == 6 /* Tag_CPU_arch. */)
14528 {
14529 val = read_uleb128 (p, &len, end);
14530 p += len;
14531 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
14532 printf ("??? (%d)\n", val);
14533 else
14534 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
14535 }
14536 else
14537 printf ("???\n");
14538 while (p < end && *(p++) != '\0' /* NUL terminator. */)
14539 ;
14540 break;
14541
14542 default:
14543 printf (_("<unknown: %d>\n"), tag);
14544 break;
14545 }
14546 return p;
14547
14548 case 1:
14549 return display_tag_value (-1, p, end);
14550 case 2:
14551 return display_tag_value (0, p, end);
14552
14553 default:
14554 assert (attr->type & 0x80);
14555 val = read_uleb128 (p, &len, end);
14556 p += len;
14557 type = attr->type & 0x7f;
14558 if (val >= type)
14559 printf ("??? (%d)\n", val);
14560 else
14561 printf ("%s\n", attr->table[val]);
14562 return p;
14563 }
14564 }
14565
14566 return display_tag_value (tag, p, end);
14567 }
14568
14569 static unsigned char *
14570 display_gnu_attribute (unsigned char * p,
14571 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
14572 const unsigned char * const end)
14573 {
14574 int tag;
14575 unsigned int len;
14576 unsigned int val;
14577
14578 tag = read_uleb128 (p, &len, end);
14579 p += len;
14580
14581 /* Tag_compatibility is the only generic GNU attribute defined at
14582 present. */
14583 if (tag == 32)
14584 {
14585 val = read_uleb128 (p, &len, end);
14586 p += len;
14587
14588 printf (_("flag = %d, vendor = "), val);
14589 if (p == end)
14590 {
14591 printf (_("<corrupt>\n"));
14592 warn (_("corrupt vendor attribute\n"));
14593 }
14594 else
14595 {
14596 if (p < end - 1)
14597 {
14598 size_t maxlen = (end - p) - 1;
14599
14600 print_symbol ((int) maxlen, (const char *) p);
14601 p += strnlen ((char *) p, maxlen) + 1;
14602 }
14603 else
14604 {
14605 printf (_("<corrupt>"));
14606 p = (unsigned char *) end;
14607 }
14608 putchar ('\n');
14609 }
14610 return p;
14611 }
14612
14613 if ((tag & 2) == 0 && display_proc_gnu_attribute)
14614 return display_proc_gnu_attribute (p, tag, end);
14615
14616 return display_tag_value (tag, p, end);
14617 }
14618
14619 static unsigned char *
14620 display_power_gnu_attribute (unsigned char * p,
14621 unsigned int tag,
14622 const unsigned char * const end)
14623 {
14624 unsigned int len;
14625 unsigned int val;
14626
14627 if (tag == Tag_GNU_Power_ABI_FP)
14628 {
14629 val = read_uleb128 (p, &len, end);
14630 p += len;
14631 printf (" Tag_GNU_Power_ABI_FP: ");
14632 if (len == 0)
14633 {
14634 printf (_("<corrupt>\n"));
14635 return p;
14636 }
14637
14638 if (val > 15)
14639 printf ("(%#x), ", val);
14640
14641 switch (val & 3)
14642 {
14643 case 0:
14644 printf (_("unspecified hard/soft float, "));
14645 break;
14646 case 1:
14647 printf (_("hard float, "));
14648 break;
14649 case 2:
14650 printf (_("soft float, "));
14651 break;
14652 case 3:
14653 printf (_("single-precision hard float, "));
14654 break;
14655 }
14656
14657 switch (val & 0xC)
14658 {
14659 case 0:
14660 printf (_("unspecified long double\n"));
14661 break;
14662 case 4:
14663 printf (_("128-bit IBM long double\n"));
14664 break;
14665 case 8:
14666 printf (_("64-bit long double\n"));
14667 break;
14668 case 12:
14669 printf (_("128-bit IEEE long double\n"));
14670 break;
14671 }
14672 return p;
14673 }
14674
14675 if (tag == Tag_GNU_Power_ABI_Vector)
14676 {
14677 val = read_uleb128 (p, &len, end);
14678 p += len;
14679 printf (" Tag_GNU_Power_ABI_Vector: ");
14680 if (len == 0)
14681 {
14682 printf (_("<corrupt>\n"));
14683 return p;
14684 }
14685
14686 if (val > 3)
14687 printf ("(%#x), ", val);
14688
14689 switch (val & 3)
14690 {
14691 case 0:
14692 printf (_("unspecified\n"));
14693 break;
14694 case 1:
14695 printf (_("generic\n"));
14696 break;
14697 case 2:
14698 printf ("AltiVec\n");
14699 break;
14700 case 3:
14701 printf ("SPE\n");
14702 break;
14703 }
14704 return p;
14705 }
14706
14707 if (tag == Tag_GNU_Power_ABI_Struct_Return)
14708 {
14709 val = read_uleb128 (p, &len, end);
14710 p += len;
14711 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
14712 if (len == 0)
14713 {
14714 printf (_("<corrupt>\n"));
14715 return p;
14716 }
14717
14718 if (val > 2)
14719 printf ("(%#x), ", val);
14720
14721 switch (val & 3)
14722 {
14723 case 0:
14724 printf (_("unspecified\n"));
14725 break;
14726 case 1:
14727 printf ("r3/r4\n");
14728 break;
14729 case 2:
14730 printf (_("memory\n"));
14731 break;
14732 case 3:
14733 printf ("???\n");
14734 break;
14735 }
14736 return p;
14737 }
14738
14739 return display_tag_value (tag & 1, p, end);
14740 }
14741
14742 static unsigned char *
14743 display_s390_gnu_attribute (unsigned char * p,
14744 unsigned int tag,
14745 const unsigned char * const end)
14746 {
14747 unsigned int len;
14748 int val;
14749
14750 if (tag == Tag_GNU_S390_ABI_Vector)
14751 {
14752 val = read_uleb128 (p, &len, end);
14753 p += len;
14754 printf (" Tag_GNU_S390_ABI_Vector: ");
14755
14756 switch (val)
14757 {
14758 case 0:
14759 printf (_("any\n"));
14760 break;
14761 case 1:
14762 printf (_("software\n"));
14763 break;
14764 case 2:
14765 printf (_("hardware\n"));
14766 break;
14767 default:
14768 printf ("??? (%d)\n", val);
14769 break;
14770 }
14771 return p;
14772 }
14773
14774 return display_tag_value (tag & 1, p, end);
14775 }
14776
14777 static void
14778 display_sparc_hwcaps (unsigned int mask)
14779 {
14780 if (mask)
14781 {
14782 bfd_boolean first = TRUE;
14783
14784 if (mask & ELF_SPARC_HWCAP_MUL32)
14785 fputs ("mul32", stdout), first = FALSE;
14786 if (mask & ELF_SPARC_HWCAP_DIV32)
14787 printf ("%sdiv32", first ? "" : "|"), first = FALSE;
14788 if (mask & ELF_SPARC_HWCAP_FSMULD)
14789 printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
14790 if (mask & ELF_SPARC_HWCAP_V8PLUS)
14791 printf ("%sv8plus", first ? "" : "|"), first = FALSE;
14792 if (mask & ELF_SPARC_HWCAP_POPC)
14793 printf ("%spopc", first ? "" : "|"), first = FALSE;
14794 if (mask & ELF_SPARC_HWCAP_VIS)
14795 printf ("%svis", first ? "" : "|"), first = FALSE;
14796 if (mask & ELF_SPARC_HWCAP_VIS2)
14797 printf ("%svis2", first ? "" : "|"), first = FALSE;
14798 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
14799 printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
14800 if (mask & ELF_SPARC_HWCAP_FMAF)
14801 printf ("%sfmaf", first ? "" : "|"), first = FALSE;
14802 if (mask & ELF_SPARC_HWCAP_VIS3)
14803 printf ("%svis3", first ? "" : "|"), first = FALSE;
14804 if (mask & ELF_SPARC_HWCAP_HPC)
14805 printf ("%shpc", first ? "" : "|"), first = FALSE;
14806 if (mask & ELF_SPARC_HWCAP_RANDOM)
14807 printf ("%srandom", first ? "" : "|"), first = FALSE;
14808 if (mask & ELF_SPARC_HWCAP_TRANS)
14809 printf ("%strans", first ? "" : "|"), first = FALSE;
14810 if (mask & ELF_SPARC_HWCAP_FJFMAU)
14811 printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
14812 if (mask & ELF_SPARC_HWCAP_IMA)
14813 printf ("%sima", first ? "" : "|"), first = FALSE;
14814 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
14815 printf ("%scspare", first ? "" : "|"), first = FALSE;
14816 }
14817 else
14818 fputc ('0', stdout);
14819 fputc ('\n', stdout);
14820 }
14821
14822 static void
14823 display_sparc_hwcaps2 (unsigned int mask)
14824 {
14825 if (mask)
14826 {
14827 bfd_boolean first = TRUE;
14828
14829 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
14830 fputs ("fjathplus", stdout), first = FALSE;
14831 if (mask & ELF_SPARC_HWCAP2_VIS3B)
14832 printf ("%svis3b", first ? "" : "|"), first = FALSE;
14833 if (mask & ELF_SPARC_HWCAP2_ADP)
14834 printf ("%sadp", first ? "" : "|"), first = FALSE;
14835 if (mask & ELF_SPARC_HWCAP2_SPARC5)
14836 printf ("%ssparc5", first ? "" : "|"), first = FALSE;
14837 if (mask & ELF_SPARC_HWCAP2_MWAIT)
14838 printf ("%smwait", first ? "" : "|"), first = FALSE;
14839 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
14840 printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
14841 if (mask & ELF_SPARC_HWCAP2_XMONT)
14842 printf ("%sxmont2", first ? "" : "|"), first = FALSE;
14843 if (mask & ELF_SPARC_HWCAP2_NSEC)
14844 printf ("%snsec", first ? "" : "|"), first = FALSE;
14845 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
14846 printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
14847 if (mask & ELF_SPARC_HWCAP2_FJDES)
14848 printf ("%sfjdes", first ? "" : "|"), first = FALSE;
14849 if (mask & ELF_SPARC_HWCAP2_FJAES)
14850 printf ("%sfjaes", first ? "" : "|"), first = FALSE;
14851 }
14852 else
14853 fputc ('0', stdout);
14854 fputc ('\n', stdout);
14855 }
14856
14857 static unsigned char *
14858 display_sparc_gnu_attribute (unsigned char * p,
14859 unsigned int tag,
14860 const unsigned char * const end)
14861 {
14862 unsigned int len;
14863 int val;
14864
14865 if (tag == Tag_GNU_Sparc_HWCAPS)
14866 {
14867 val = read_uleb128 (p, &len, end);
14868 p += len;
14869 printf (" Tag_GNU_Sparc_HWCAPS: ");
14870 display_sparc_hwcaps (val);
14871 return p;
14872 }
14873 if (tag == Tag_GNU_Sparc_HWCAPS2)
14874 {
14875 val = read_uleb128 (p, &len, end);
14876 p += len;
14877 printf (" Tag_GNU_Sparc_HWCAPS2: ");
14878 display_sparc_hwcaps2 (val);
14879 return p;
14880 }
14881
14882 return display_tag_value (tag, p, end);
14883 }
14884
14885 static void
14886 print_mips_fp_abi_value (unsigned int val)
14887 {
14888 switch (val)
14889 {
14890 case Val_GNU_MIPS_ABI_FP_ANY:
14891 printf (_("Hard or soft float\n"));
14892 break;
14893 case Val_GNU_MIPS_ABI_FP_DOUBLE:
14894 printf (_("Hard float (double precision)\n"));
14895 break;
14896 case Val_GNU_MIPS_ABI_FP_SINGLE:
14897 printf (_("Hard float (single precision)\n"));
14898 break;
14899 case Val_GNU_MIPS_ABI_FP_SOFT:
14900 printf (_("Soft float\n"));
14901 break;
14902 case Val_GNU_MIPS_ABI_FP_OLD_64:
14903 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14904 break;
14905 case Val_GNU_MIPS_ABI_FP_XX:
14906 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14907 break;
14908 case Val_GNU_MIPS_ABI_FP_64:
14909 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14910 break;
14911 case Val_GNU_MIPS_ABI_FP_64A:
14912 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14913 break;
14914 case Val_GNU_MIPS_ABI_FP_NAN2008:
14915 printf (_("NaN 2008 compatibility\n"));
14916 break;
14917 default:
14918 printf ("??? (%d)\n", val);
14919 break;
14920 }
14921 }
14922
14923 static unsigned char *
14924 display_mips_gnu_attribute (unsigned char * p,
14925 unsigned int tag,
14926 const unsigned char * const end)
14927 {
14928 if (tag == Tag_GNU_MIPS_ABI_FP)
14929 {
14930 unsigned int len;
14931 unsigned int val;
14932
14933 val = read_uleb128 (p, &len, end);
14934 p += len;
14935 printf (" Tag_GNU_MIPS_ABI_FP: ");
14936
14937 print_mips_fp_abi_value (val);
14938
14939 return p;
14940 }
14941
14942 if (tag == Tag_GNU_MIPS_ABI_MSA)
14943 {
14944 unsigned int len;
14945 unsigned int val;
14946
14947 val = read_uleb128 (p, &len, end);
14948 p += len;
14949 printf (" Tag_GNU_MIPS_ABI_MSA: ");
14950
14951 switch (val)
14952 {
14953 case Val_GNU_MIPS_ABI_MSA_ANY:
14954 printf (_("Any MSA or not\n"));
14955 break;
14956 case Val_GNU_MIPS_ABI_MSA_128:
14957 printf (_("128-bit MSA\n"));
14958 break;
14959 default:
14960 printf ("??? (%d)\n", val);
14961 break;
14962 }
14963 return p;
14964 }
14965
14966 return display_tag_value (tag & 1, p, end);
14967 }
14968
14969 static unsigned char *
14970 display_tic6x_attribute (unsigned char * p,
14971 const unsigned char * const end)
14972 {
14973 unsigned int tag;
14974 unsigned int len;
14975 int val;
14976
14977 tag = read_uleb128 (p, &len, end);
14978 p += len;
14979
14980 switch (tag)
14981 {
14982 case Tag_ISA:
14983 val = read_uleb128 (p, &len, end);
14984 p += len;
14985 printf (" Tag_ISA: ");
14986
14987 switch (val)
14988 {
14989 case C6XABI_Tag_ISA_none:
14990 printf (_("None\n"));
14991 break;
14992 case C6XABI_Tag_ISA_C62X:
14993 printf ("C62x\n");
14994 break;
14995 case C6XABI_Tag_ISA_C67X:
14996 printf ("C67x\n");
14997 break;
14998 case C6XABI_Tag_ISA_C67XP:
14999 printf ("C67x+\n");
15000 break;
15001 case C6XABI_Tag_ISA_C64X:
15002 printf ("C64x\n");
15003 break;
15004 case C6XABI_Tag_ISA_C64XP:
15005 printf ("C64x+\n");
15006 break;
15007 case C6XABI_Tag_ISA_C674X:
15008 printf ("C674x\n");
15009 break;
15010 default:
15011 printf ("??? (%d)\n", val);
15012 break;
15013 }
15014 return p;
15015
15016 case Tag_ABI_wchar_t:
15017 val = read_uleb128 (p, &len, end);
15018 p += len;
15019 printf (" Tag_ABI_wchar_t: ");
15020 switch (val)
15021 {
15022 case 0:
15023 printf (_("Not used\n"));
15024 break;
15025 case 1:
15026 printf (_("2 bytes\n"));
15027 break;
15028 case 2:
15029 printf (_("4 bytes\n"));
15030 break;
15031 default:
15032 printf ("??? (%d)\n", val);
15033 break;
15034 }
15035 return p;
15036
15037 case Tag_ABI_stack_align_needed:
15038 val = read_uleb128 (p, &len, end);
15039 p += len;
15040 printf (" Tag_ABI_stack_align_needed: ");
15041 switch (val)
15042 {
15043 case 0:
15044 printf (_("8-byte\n"));
15045 break;
15046 case 1:
15047 printf (_("16-byte\n"));
15048 break;
15049 default:
15050 printf ("??? (%d)\n", val);
15051 break;
15052 }
15053 return p;
15054
15055 case Tag_ABI_stack_align_preserved:
15056 val = read_uleb128 (p, &len, end);
15057 p += len;
15058 printf (" Tag_ABI_stack_align_preserved: ");
15059 switch (val)
15060 {
15061 case 0:
15062 printf (_("8-byte\n"));
15063 break;
15064 case 1:
15065 printf (_("16-byte\n"));
15066 break;
15067 default:
15068 printf ("??? (%d)\n", val);
15069 break;
15070 }
15071 return p;
15072
15073 case Tag_ABI_DSBT:
15074 val = read_uleb128 (p, &len, end);
15075 p += len;
15076 printf (" Tag_ABI_DSBT: ");
15077 switch (val)
15078 {
15079 case 0:
15080 printf (_("DSBT addressing not used\n"));
15081 break;
15082 case 1:
15083 printf (_("DSBT addressing used\n"));
15084 break;
15085 default:
15086 printf ("??? (%d)\n", val);
15087 break;
15088 }
15089 return p;
15090
15091 case Tag_ABI_PID:
15092 val = read_uleb128 (p, &len, end);
15093 p += len;
15094 printf (" Tag_ABI_PID: ");
15095 switch (val)
15096 {
15097 case 0:
15098 printf (_("Data addressing position-dependent\n"));
15099 break;
15100 case 1:
15101 printf (_("Data addressing position-independent, GOT near DP\n"));
15102 break;
15103 case 2:
15104 printf (_("Data addressing position-independent, GOT far from DP\n"));
15105 break;
15106 default:
15107 printf ("??? (%d)\n", val);
15108 break;
15109 }
15110 return p;
15111
15112 case Tag_ABI_PIC:
15113 val = read_uleb128 (p, &len, end);
15114 p += len;
15115 printf (" Tag_ABI_PIC: ");
15116 switch (val)
15117 {
15118 case 0:
15119 printf (_("Code addressing position-dependent\n"));
15120 break;
15121 case 1:
15122 printf (_("Code addressing position-independent\n"));
15123 break;
15124 default:
15125 printf ("??? (%d)\n", val);
15126 break;
15127 }
15128 return p;
15129
15130 case Tag_ABI_array_object_alignment:
15131 val = read_uleb128 (p, &len, end);
15132 p += len;
15133 printf (" Tag_ABI_array_object_alignment: ");
15134 switch (val)
15135 {
15136 case 0:
15137 printf (_("8-byte\n"));
15138 break;
15139 case 1:
15140 printf (_("4-byte\n"));
15141 break;
15142 case 2:
15143 printf (_("16-byte\n"));
15144 break;
15145 default:
15146 printf ("??? (%d)\n", val);
15147 break;
15148 }
15149 return p;
15150
15151 case Tag_ABI_array_object_align_expected:
15152 val = read_uleb128 (p, &len, end);
15153 p += len;
15154 printf (" Tag_ABI_array_object_align_expected: ");
15155 switch (val)
15156 {
15157 case 0:
15158 printf (_("8-byte\n"));
15159 break;
15160 case 1:
15161 printf (_("4-byte\n"));
15162 break;
15163 case 2:
15164 printf (_("16-byte\n"));
15165 break;
15166 default:
15167 printf ("??? (%d)\n", val);
15168 break;
15169 }
15170 return p;
15171
15172 case Tag_ABI_compatibility:
15173 {
15174 val = read_uleb128 (p, &len, end);
15175 p += len;
15176 printf (" Tag_ABI_compatibility: ");
15177 printf (_("flag = %d, vendor = "), val);
15178 if (p < end - 1)
15179 {
15180 size_t maxlen = (end - p) - 1;
15181
15182 print_symbol ((int) maxlen, (const char *) p);
15183 p += strnlen ((char *) p, maxlen) + 1;
15184 }
15185 else
15186 {
15187 printf (_("<corrupt>"));
15188 p = (unsigned char *) end;
15189 }
15190 putchar ('\n');
15191 return p;
15192 }
15193
15194 case Tag_ABI_conformance:
15195 {
15196 printf (" Tag_ABI_conformance: \"");
15197 if (p < end - 1)
15198 {
15199 size_t maxlen = (end - p) - 1;
15200
15201 print_symbol ((int) maxlen, (const char *) p);
15202 p += strnlen ((char *) p, maxlen) + 1;
15203 }
15204 else
15205 {
15206 printf (_("<corrupt>"));
15207 p = (unsigned char *) end;
15208 }
15209 printf ("\"\n");
15210 return p;
15211 }
15212 }
15213
15214 return display_tag_value (tag, p, end);
15215 }
15216
15217 static void
15218 display_raw_attribute (unsigned char * p, unsigned char const * const end)
15219 {
15220 unsigned long addr = 0;
15221 size_t bytes = end - p;
15222
15223 assert (end > p);
15224 while (bytes)
15225 {
15226 int j;
15227 int k;
15228 int lbytes = (bytes > 16 ? 16 : bytes);
15229
15230 printf (" 0x%8.8lx ", addr);
15231
15232 for (j = 0; j < 16; j++)
15233 {
15234 if (j < lbytes)
15235 printf ("%2.2x", p[j]);
15236 else
15237 printf (" ");
15238
15239 if ((j & 3) == 3)
15240 printf (" ");
15241 }
15242
15243 for (j = 0; j < lbytes; j++)
15244 {
15245 k = p[j];
15246 if (k >= ' ' && k < 0x7f)
15247 printf ("%c", k);
15248 else
15249 printf (".");
15250 }
15251
15252 putchar ('\n');
15253
15254 p += lbytes;
15255 bytes -= lbytes;
15256 addr += lbytes;
15257 }
15258
15259 putchar ('\n');
15260 }
15261
15262 static unsigned char *
15263 display_msp430x_attribute (unsigned char * p,
15264 const unsigned char * const end)
15265 {
15266 unsigned int len;
15267 unsigned int val;
15268 unsigned int tag;
15269
15270 tag = read_uleb128 (p, & len, end);
15271 p += len;
15272
15273 switch (tag)
15274 {
15275 case OFBA_MSPABI_Tag_ISA:
15276 val = read_uleb128 (p, &len, end);
15277 p += len;
15278 printf (" Tag_ISA: ");
15279 switch (val)
15280 {
15281 case 0: printf (_("None\n")); break;
15282 case 1: printf (_("MSP430\n")); break;
15283 case 2: printf (_("MSP430X\n")); break;
15284 default: printf ("??? (%d)\n", val); break;
15285 }
15286 break;
15287
15288 case OFBA_MSPABI_Tag_Code_Model:
15289 val = read_uleb128 (p, &len, end);
15290 p += len;
15291 printf (" Tag_Code_Model: ");
15292 switch (val)
15293 {
15294 case 0: printf (_("None\n")); break;
15295 case 1: printf (_("Small\n")); break;
15296 case 2: printf (_("Large\n")); break;
15297 default: printf ("??? (%d)\n", val); break;
15298 }
15299 break;
15300
15301 case OFBA_MSPABI_Tag_Data_Model:
15302 val = read_uleb128 (p, &len, end);
15303 p += len;
15304 printf (" Tag_Data_Model: ");
15305 switch (val)
15306 {
15307 case 0: printf (_("None\n")); break;
15308 case 1: printf (_("Small\n")); break;
15309 case 2: printf (_("Large\n")); break;
15310 case 3: printf (_("Restricted Large\n")); break;
15311 default: printf ("??? (%d)\n", val); break;
15312 }
15313 break;
15314
15315 default:
15316 printf (_(" <unknown tag %d>: "), tag);
15317
15318 if (tag & 1)
15319 {
15320 putchar ('"');
15321 if (p < end - 1)
15322 {
15323 size_t maxlen = (end - p) - 1;
15324
15325 print_symbol ((int) maxlen, (const char *) p);
15326 p += strnlen ((char *) p, maxlen) + 1;
15327 }
15328 else
15329 {
15330 printf (_("<corrupt>"));
15331 p = (unsigned char *) end;
15332 }
15333 printf ("\"\n");
15334 }
15335 else
15336 {
15337 val = read_uleb128 (p, &len, end);
15338 p += len;
15339 printf ("%d (0x%x)\n", val, val);
15340 }
15341 break;
15342 }
15343
15344 assert (p <= end);
15345 return p;
15346 }
15347
15348 static bfd_boolean
15349 process_attributes (Filedata * filedata,
15350 const char * public_name,
15351 unsigned int proc_type,
15352 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
15353 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
15354 {
15355 Elf_Internal_Shdr * sect;
15356 unsigned i;
15357 bfd_boolean res = TRUE;
15358
15359 /* Find the section header so that we get the size. */
15360 for (i = 0, sect = filedata->section_headers;
15361 i < filedata->file_header.e_shnum;
15362 i++, sect++)
15363 {
15364 unsigned char * contents;
15365 unsigned char * p;
15366
15367 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
15368 continue;
15369
15370 contents = (unsigned char *) get_data (NULL, filedata, sect->sh_offset, 1,
15371 sect->sh_size, _("attributes"));
15372 if (contents == NULL)
15373 {
15374 res = FALSE;
15375 continue;
15376 }
15377
15378 p = contents;
15379 /* The first character is the version of the attributes.
15380 Currently only version 1, (aka 'A') is recognised here. */
15381 if (*p != 'A')
15382 {
15383 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
15384 res = FALSE;
15385 }
15386 else
15387 {
15388 bfd_vma section_len;
15389
15390 section_len = sect->sh_size - 1;
15391 p++;
15392
15393 while (section_len > 0)
15394 {
15395 bfd_vma attr_len;
15396 unsigned int namelen;
15397 bfd_boolean public_section;
15398 bfd_boolean gnu_section;
15399
15400 if (section_len <= 4)
15401 {
15402 error (_("Tag section ends prematurely\n"));
15403 res = FALSE;
15404 break;
15405 }
15406 attr_len = byte_get (p, 4);
15407 p += 4;
15408
15409 if (attr_len > section_len)
15410 {
15411 error (_("Bad attribute length (%u > %u)\n"),
15412 (unsigned) attr_len, (unsigned) section_len);
15413 attr_len = section_len;
15414 res = FALSE;
15415 }
15416 /* PR 17531: file: 001-101425-0.004 */
15417 else if (attr_len < 5)
15418 {
15419 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
15420 res = FALSE;
15421 break;
15422 }
15423
15424 section_len -= attr_len;
15425 attr_len -= 4;
15426
15427 namelen = strnlen ((char *) p, attr_len) + 1;
15428 if (namelen == 0 || namelen >= attr_len)
15429 {
15430 error (_("Corrupt attribute section name\n"));
15431 res = FALSE;
15432 break;
15433 }
15434
15435 printf (_("Attribute Section: "));
15436 print_symbol (INT_MAX, (const char *) p);
15437 putchar ('\n');
15438
15439 if (public_name && streq ((char *) p, public_name))
15440 public_section = TRUE;
15441 else
15442 public_section = FALSE;
15443
15444 if (streq ((char *) p, "gnu"))
15445 gnu_section = TRUE;
15446 else
15447 gnu_section = FALSE;
15448
15449 p += namelen;
15450 attr_len -= namelen;
15451
15452 while (attr_len > 0 && p < contents + sect->sh_size)
15453 {
15454 int tag;
15455 int val;
15456 bfd_vma size;
15457 unsigned char * end;
15458
15459 /* PR binutils/17531: Safe handling of corrupt files. */
15460 if (attr_len < 6)
15461 {
15462 error (_("Unused bytes at end of section\n"));
15463 res = FALSE;
15464 section_len = 0;
15465 break;
15466 }
15467
15468 tag = *(p++);
15469 size = byte_get (p, 4);
15470 if (size > attr_len)
15471 {
15472 error (_("Bad subsection length (%u > %u)\n"),
15473 (unsigned) size, (unsigned) attr_len);
15474 res = FALSE;
15475 size = attr_len;
15476 }
15477 /* PR binutils/17531: Safe handling of corrupt files. */
15478 if (size < 6)
15479 {
15480 error (_("Bad subsection length (%u < 6)\n"),
15481 (unsigned) size);
15482 res = FALSE;
15483 section_len = 0;
15484 break;
15485 }
15486
15487 attr_len -= size;
15488 end = p + size - 1;
15489 assert (end <= contents + sect->sh_size);
15490 p += 4;
15491
15492 switch (tag)
15493 {
15494 case 1:
15495 printf (_("File Attributes\n"));
15496 break;
15497 case 2:
15498 printf (_("Section Attributes:"));
15499 goto do_numlist;
15500 case 3:
15501 printf (_("Symbol Attributes:"));
15502 /* Fall through. */
15503 do_numlist:
15504 for (;;)
15505 {
15506 unsigned int j;
15507
15508 val = read_uleb128 (p, &j, end);
15509 p += j;
15510 if (val == 0)
15511 break;
15512 printf (" %d", val);
15513 }
15514 printf ("\n");
15515 break;
15516 default:
15517 printf (_("Unknown tag: %d\n"), tag);
15518 public_section = FALSE;
15519 break;
15520 }
15521
15522 if (public_section && display_pub_attribute != NULL)
15523 {
15524 while (p < end)
15525 p = display_pub_attribute (p, end);
15526 assert (p == end);
15527 }
15528 else if (gnu_section && display_proc_gnu_attribute != NULL)
15529 {
15530 while (p < end)
15531 p = display_gnu_attribute (p,
15532 display_proc_gnu_attribute,
15533 end);
15534 assert (p == end);
15535 }
15536 else if (p < end)
15537 {
15538 printf (_(" Unknown attribute:\n"));
15539 display_raw_attribute (p, end);
15540 p = end;
15541 }
15542 else
15543 attr_len = 0;
15544 }
15545 }
15546 }
15547
15548 free (contents);
15549 }
15550
15551 return res;
15552 }
15553
15554 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15555 Print the Address, Access and Initial fields of an entry at VMA ADDR
15556 and return the VMA of the next entry, or -1 if there was a problem.
15557 Does not read from DATA_END or beyond. */
15558
15559 static bfd_vma
15560 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
15561 unsigned char * data_end)
15562 {
15563 printf (" ");
15564 print_vma (addr, LONG_HEX);
15565 printf (" ");
15566 if (addr < pltgot + 0xfff0)
15567 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
15568 else
15569 printf ("%10s", "");
15570 printf (" ");
15571 if (data == NULL)
15572 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15573 else
15574 {
15575 bfd_vma entry;
15576 unsigned char * from = data + addr - pltgot;
15577
15578 if (from + (is_32bit_elf ? 4 : 8) > data_end)
15579 {
15580 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15581 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
15582 return (bfd_vma) -1;
15583 }
15584 else
15585 {
15586 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15587 print_vma (entry, LONG_HEX);
15588 }
15589 }
15590 return addr + (is_32bit_elf ? 4 : 8);
15591 }
15592
15593 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15594 PLTGOT. Print the Address and Initial fields of an entry at VMA
15595 ADDR and return the VMA of the next entry. */
15596
15597 static bfd_vma
15598 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
15599 {
15600 printf (" ");
15601 print_vma (addr, LONG_HEX);
15602 printf (" ");
15603 if (data == NULL)
15604 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
15605 else
15606 {
15607 bfd_vma entry;
15608
15609 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
15610 print_vma (entry, LONG_HEX);
15611 }
15612 return addr + (is_32bit_elf ? 4 : 8);
15613 }
15614
15615 static void
15616 print_mips_ases (unsigned int mask)
15617 {
15618 if (mask & AFL_ASE_DSP)
15619 fputs ("\n\tDSP ASE", stdout);
15620 if (mask & AFL_ASE_DSPR2)
15621 fputs ("\n\tDSP R2 ASE", stdout);
15622 if (mask & AFL_ASE_DSPR3)
15623 fputs ("\n\tDSP R3 ASE", stdout);
15624 if (mask & AFL_ASE_EVA)
15625 fputs ("\n\tEnhanced VA Scheme", stdout);
15626 if (mask & AFL_ASE_MCU)
15627 fputs ("\n\tMCU (MicroController) ASE", stdout);
15628 if (mask & AFL_ASE_MDMX)
15629 fputs ("\n\tMDMX ASE", stdout);
15630 if (mask & AFL_ASE_MIPS3D)
15631 fputs ("\n\tMIPS-3D ASE", stdout);
15632 if (mask & AFL_ASE_MT)
15633 fputs ("\n\tMT ASE", stdout);
15634 if (mask & AFL_ASE_SMARTMIPS)
15635 fputs ("\n\tSmartMIPS ASE", stdout);
15636 if (mask & AFL_ASE_VIRT)
15637 fputs ("\n\tVZ ASE", stdout);
15638 if (mask & AFL_ASE_MSA)
15639 fputs ("\n\tMSA ASE", stdout);
15640 if (mask & AFL_ASE_MIPS16)
15641 fputs ("\n\tMIPS16 ASE", stdout);
15642 if (mask & AFL_ASE_MICROMIPS)
15643 fputs ("\n\tMICROMIPS ASE", stdout);
15644 if (mask & AFL_ASE_XPA)
15645 fputs ("\n\tXPA ASE", stdout);
15646 if (mask & AFL_ASE_MIPS16E2)
15647 fputs ("\n\tMIPS16e2 ASE", stdout);
15648 if (mask & AFL_ASE_CRC)
15649 fputs ("\n\tCRC ASE", stdout);
15650 if (mask & AFL_ASE_GINV)
15651 fputs ("\n\tGINV ASE", stdout);
15652 if (mask & AFL_ASE_LOONGSON_MMI)
15653 fputs ("\n\tLoongson MMI ASE", stdout);
15654 if (mask & AFL_ASE_LOONGSON_CAM)
15655 fputs ("\n\tLoongson CAM ASE", stdout);
15656 if (mask & AFL_ASE_LOONGSON_EXT)
15657 fputs ("\n\tLoongson EXT ASE", stdout);
15658 if (mask & AFL_ASE_LOONGSON_EXT2)
15659 fputs ("\n\tLoongson EXT2 ASE", stdout);
15660 if (mask == 0)
15661 fprintf (stdout, "\n\t%s", _("None"));
15662 else if ((mask & ~AFL_ASE_MASK) != 0)
15663 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
15664 }
15665
15666 static void
15667 print_mips_isa_ext (unsigned int isa_ext)
15668 {
15669 switch (isa_ext)
15670 {
15671 case 0:
15672 fputs (_("None"), stdout);
15673 break;
15674 case AFL_EXT_XLR:
15675 fputs ("RMI XLR", stdout);
15676 break;
15677 case AFL_EXT_OCTEON3:
15678 fputs ("Cavium Networks Octeon3", stdout);
15679 break;
15680 case AFL_EXT_OCTEON2:
15681 fputs ("Cavium Networks Octeon2", stdout);
15682 break;
15683 case AFL_EXT_OCTEONP:
15684 fputs ("Cavium Networks OcteonP", stdout);
15685 break;
15686 case AFL_EXT_LOONGSON_3A:
15687 fputs ("Loongson 3A", stdout);
15688 break;
15689 case AFL_EXT_OCTEON:
15690 fputs ("Cavium Networks Octeon", stdout);
15691 break;
15692 case AFL_EXT_5900:
15693 fputs ("Toshiba R5900", stdout);
15694 break;
15695 case AFL_EXT_4650:
15696 fputs ("MIPS R4650", stdout);
15697 break;
15698 case AFL_EXT_4010:
15699 fputs ("LSI R4010", stdout);
15700 break;
15701 case AFL_EXT_4100:
15702 fputs ("NEC VR4100", stdout);
15703 break;
15704 case AFL_EXT_3900:
15705 fputs ("Toshiba R3900", stdout);
15706 break;
15707 case AFL_EXT_10000:
15708 fputs ("MIPS R10000", stdout);
15709 break;
15710 case AFL_EXT_SB1:
15711 fputs ("Broadcom SB-1", stdout);
15712 break;
15713 case AFL_EXT_4111:
15714 fputs ("NEC VR4111/VR4181", stdout);
15715 break;
15716 case AFL_EXT_4120:
15717 fputs ("NEC VR4120", stdout);
15718 break;
15719 case AFL_EXT_5400:
15720 fputs ("NEC VR5400", stdout);
15721 break;
15722 case AFL_EXT_5500:
15723 fputs ("NEC VR5500", stdout);
15724 break;
15725 case AFL_EXT_LOONGSON_2E:
15726 fputs ("ST Microelectronics Loongson 2E", stdout);
15727 break;
15728 case AFL_EXT_LOONGSON_2F:
15729 fputs ("ST Microelectronics Loongson 2F", stdout);
15730 break;
15731 case AFL_EXT_INTERAPTIV_MR2:
15732 fputs ("Imagination interAptiv MR2", stdout);
15733 break;
15734 default:
15735 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
15736 }
15737 }
15738
15739 static signed int
15740 get_mips_reg_size (int reg_size)
15741 {
15742 return (reg_size == AFL_REG_NONE) ? 0
15743 : (reg_size == AFL_REG_32) ? 32
15744 : (reg_size == AFL_REG_64) ? 64
15745 : (reg_size == AFL_REG_128) ? 128
15746 : -1;
15747 }
15748
15749 static bfd_boolean
15750 process_mips_specific (Filedata * filedata)
15751 {
15752 Elf_Internal_Dyn * entry;
15753 Elf_Internal_Shdr *sect = NULL;
15754 size_t liblist_offset = 0;
15755 size_t liblistno = 0;
15756 size_t conflictsno = 0;
15757 size_t options_offset = 0;
15758 size_t conflicts_offset = 0;
15759 size_t pltrelsz = 0;
15760 size_t pltrel = 0;
15761 bfd_vma pltgot = 0;
15762 bfd_vma mips_pltgot = 0;
15763 bfd_vma jmprel = 0;
15764 bfd_vma local_gotno = 0;
15765 bfd_vma gotsym = 0;
15766 bfd_vma symtabno = 0;
15767 bfd_boolean res = TRUE;
15768
15769 if (! process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
15770 display_mips_gnu_attribute))
15771 res = FALSE;
15772
15773 sect = find_section (filedata, ".MIPS.abiflags");
15774
15775 if (sect != NULL)
15776 {
15777 Elf_External_ABIFlags_v0 *abiflags_ext;
15778 Elf_Internal_ABIFlags_v0 abiflags_in;
15779
15780 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
15781 {
15782 error (_("Corrupt MIPS ABI Flags section.\n"));
15783 res = FALSE;
15784 }
15785 else
15786 {
15787 abiflags_ext = get_data (NULL, filedata, sect->sh_offset, 1,
15788 sect->sh_size, _("MIPS ABI Flags section"));
15789 if (abiflags_ext)
15790 {
15791 abiflags_in.version = BYTE_GET (abiflags_ext->version);
15792 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
15793 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
15794 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
15795 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
15796 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
15797 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
15798 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
15799 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
15800 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
15801 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
15802
15803 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
15804 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
15805 if (abiflags_in.isa_rev > 1)
15806 printf ("r%d", abiflags_in.isa_rev);
15807 printf ("\nGPR size: %d",
15808 get_mips_reg_size (abiflags_in.gpr_size));
15809 printf ("\nCPR1 size: %d",
15810 get_mips_reg_size (abiflags_in.cpr1_size));
15811 printf ("\nCPR2 size: %d",
15812 get_mips_reg_size (abiflags_in.cpr2_size));
15813 fputs ("\nFP ABI: ", stdout);
15814 print_mips_fp_abi_value (abiflags_in.fp_abi);
15815 fputs ("ISA Extension: ", stdout);
15816 print_mips_isa_ext (abiflags_in.isa_ext);
15817 fputs ("\nASEs:", stdout);
15818 print_mips_ases (abiflags_in.ases);
15819 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
15820 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
15821 fputc ('\n', stdout);
15822 free (abiflags_ext);
15823 }
15824 }
15825 }
15826
15827 /* We have a lot of special sections. Thanks SGI! */
15828 if (dynamic_section == NULL)
15829 {
15830 /* No dynamic information available. See if there is static GOT. */
15831 sect = find_section (filedata, ".got");
15832 if (sect != NULL)
15833 {
15834 unsigned char *data_end;
15835 unsigned char *data;
15836 bfd_vma ent, end;
15837 int addr_size;
15838
15839 pltgot = sect->sh_addr;
15840
15841 ent = pltgot;
15842 addr_size = (is_32bit_elf ? 4 : 8);
15843 end = pltgot + sect->sh_size;
15844
15845 data = (unsigned char *) get_data (NULL, filedata, sect->sh_offset,
15846 end - pltgot, 1,
15847 _("Global Offset Table data"));
15848 /* PR 12855: Null data is handled gracefully throughout. */
15849 data_end = data + (end - pltgot);
15850
15851 printf (_("\nStatic GOT:\n"));
15852 printf (_(" Canonical gp value: "));
15853 print_vma (ent + 0x7ff0, LONG_HEX);
15854 printf ("\n\n");
15855
15856 /* In a dynamic binary GOT[0] is reserved for the dynamic
15857 loader to store the lazy resolver pointer, however in
15858 a static binary it may well have been omitted and GOT
15859 reduced to a table of addresses.
15860 PR 21344: Check for the entry being fully available
15861 before fetching it. */
15862 if (data
15863 && data + ent - pltgot + addr_size <= data_end
15864 && byte_get (data + ent - pltgot, addr_size) == 0)
15865 {
15866 printf (_(" Reserved entries:\n"));
15867 printf (_(" %*s %10s %*s\n"),
15868 addr_size * 2, _("Address"), _("Access"),
15869 addr_size * 2, _("Value"));
15870 ent = print_mips_got_entry (data, pltgot, ent, data_end);
15871 printf ("\n");
15872 if (ent == (bfd_vma) -1)
15873 goto sgot_print_fail;
15874
15875 /* Check for the MSB of GOT[1] being set, identifying a
15876 GNU object. This entry will be used by some runtime
15877 loaders, to store the module pointer. Otherwise this
15878 is an ordinary local entry.
15879 PR 21344: Check for the entry being fully available
15880 before fetching it. */
15881 if (data
15882 && data + ent - pltgot + addr_size <= data_end
15883 && (byte_get (data + ent - pltgot, addr_size)
15884 >> (addr_size * 8 - 1)) != 0)
15885 {
15886 ent = print_mips_got_entry (data, pltgot, ent, data_end);
15887 printf ("\n");
15888 if (ent == (bfd_vma) -1)
15889 goto sgot_print_fail;
15890 }
15891 printf ("\n");
15892 }
15893
15894 if (data != NULL && ent < end)
15895 {
15896 printf (_(" Local entries:\n"));
15897 printf (" %*s %10s %*s\n",
15898 addr_size * 2, _("Address"), _("Access"),
15899 addr_size * 2, _("Value"));
15900 while (ent < end)
15901 {
15902 ent = print_mips_got_entry (data, pltgot, ent, data_end);
15903 printf ("\n");
15904 if (ent == (bfd_vma) -1)
15905 goto sgot_print_fail;
15906 }
15907 printf ("\n");
15908 }
15909
15910 sgot_print_fail:
15911 if (data)
15912 free (data);
15913 }
15914 return res;
15915 }
15916
15917 for (entry = dynamic_section;
15918 /* PR 17531 file: 012-50589-0.004. */
15919 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
15920 ++entry)
15921 switch (entry->d_tag)
15922 {
15923 case DT_MIPS_LIBLIST:
15924 liblist_offset
15925 = offset_from_vma (filedata, entry->d_un.d_val,
15926 liblistno * sizeof (Elf32_External_Lib));
15927 break;
15928 case DT_MIPS_LIBLISTNO:
15929 liblistno = entry->d_un.d_val;
15930 break;
15931 case DT_MIPS_OPTIONS:
15932 options_offset = offset_from_vma (filedata, entry->d_un.d_val, 0);
15933 break;
15934 case DT_MIPS_CONFLICT:
15935 conflicts_offset
15936 = offset_from_vma (filedata, entry->d_un.d_val,
15937 conflictsno * sizeof (Elf32_External_Conflict));
15938 break;
15939 case DT_MIPS_CONFLICTNO:
15940 conflictsno = entry->d_un.d_val;
15941 break;
15942 case DT_PLTGOT:
15943 pltgot = entry->d_un.d_ptr;
15944 break;
15945 case DT_MIPS_LOCAL_GOTNO:
15946 local_gotno = entry->d_un.d_val;
15947 break;
15948 case DT_MIPS_GOTSYM:
15949 gotsym = entry->d_un.d_val;
15950 break;
15951 case DT_MIPS_SYMTABNO:
15952 symtabno = entry->d_un.d_val;
15953 break;
15954 case DT_MIPS_PLTGOT:
15955 mips_pltgot = entry->d_un.d_ptr;
15956 break;
15957 case DT_PLTREL:
15958 pltrel = entry->d_un.d_val;
15959 break;
15960 case DT_PLTRELSZ:
15961 pltrelsz = entry->d_un.d_val;
15962 break;
15963 case DT_JMPREL:
15964 jmprel = entry->d_un.d_ptr;
15965 break;
15966 default:
15967 break;
15968 }
15969
15970 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
15971 {
15972 Elf32_External_Lib * elib;
15973 size_t cnt;
15974
15975 elib = (Elf32_External_Lib *) get_data (NULL, filedata, liblist_offset,
15976 liblistno,
15977 sizeof (Elf32_External_Lib),
15978 _("liblist section data"));
15979 if (elib)
15980 {
15981 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
15982 "\nSection '.liblist' contains %lu entries:\n",
15983 (unsigned long) liblistno),
15984 (unsigned long) liblistno);
15985 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
15986 stdout);
15987
15988 for (cnt = 0; cnt < liblistno; ++cnt)
15989 {
15990 Elf32_Lib liblist;
15991 time_t atime;
15992 char timebuf[128];
15993 struct tm * tmp;
15994
15995 liblist.l_name = BYTE_GET (elib[cnt].l_name);
15996 atime = BYTE_GET (elib[cnt].l_time_stamp);
15997 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15998 liblist.l_version = BYTE_GET (elib[cnt].l_version);
15999 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16000
16001 tmp = gmtime (&atime);
16002 snprintf (timebuf, sizeof (timebuf),
16003 "%04u-%02u-%02uT%02u:%02u:%02u",
16004 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16005 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16006
16007 printf ("%3lu: ", (unsigned long) cnt);
16008 if (VALID_DYNAMIC_NAME (liblist.l_name))
16009 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
16010 else
16011 printf (_("<corrupt: %9ld>"), liblist.l_name);
16012 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
16013 liblist.l_version);
16014
16015 if (liblist.l_flags == 0)
16016 puts (_(" NONE"));
16017 else
16018 {
16019 static const struct
16020 {
16021 const char * name;
16022 int bit;
16023 }
16024 l_flags_vals[] =
16025 {
16026 { " EXACT_MATCH", LL_EXACT_MATCH },
16027 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
16028 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
16029 { " EXPORTS", LL_EXPORTS },
16030 { " DELAY_LOAD", LL_DELAY_LOAD },
16031 { " DELTA", LL_DELTA }
16032 };
16033 int flags = liblist.l_flags;
16034 size_t fcnt;
16035
16036 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
16037 if ((flags & l_flags_vals[fcnt].bit) != 0)
16038 {
16039 fputs (l_flags_vals[fcnt].name, stdout);
16040 flags ^= l_flags_vals[fcnt].bit;
16041 }
16042 if (flags != 0)
16043 printf (" %#x", (unsigned int) flags);
16044
16045 puts ("");
16046 }
16047 }
16048
16049 free (elib);
16050 }
16051 else
16052 res = FALSE;
16053 }
16054
16055 if (options_offset != 0)
16056 {
16057 Elf_External_Options * eopt;
16058 Elf_Internal_Options * iopt;
16059 Elf_Internal_Options * option;
16060 size_t offset;
16061 int cnt;
16062 sect = filedata->section_headers;
16063
16064 /* Find the section header so that we get the size. */
16065 sect = find_section_by_type (filedata, SHT_MIPS_OPTIONS);
16066 /* PR 17533 file: 012-277276-0.004. */
16067 if (sect == NULL)
16068 {
16069 error (_("No MIPS_OPTIONS header found\n"));
16070 return FALSE;
16071 }
16072
16073 eopt = (Elf_External_Options *) get_data (NULL, filedata, options_offset, 1,
16074 sect->sh_size, _("options"));
16075 if (eopt)
16076 {
16077 iopt = (Elf_Internal_Options *)
16078 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
16079 if (iopt == NULL)
16080 {
16081 error (_("Out of memory allocating space for MIPS options\n"));
16082 return FALSE;
16083 }
16084
16085 offset = cnt = 0;
16086 option = iopt;
16087
16088 while (offset <= sect->sh_size - sizeof (* eopt))
16089 {
16090 Elf_External_Options * eoption;
16091
16092 eoption = (Elf_External_Options *) ((char *) eopt + offset);
16093
16094 option->kind = BYTE_GET (eoption->kind);
16095 option->size = BYTE_GET (eoption->size);
16096 option->section = BYTE_GET (eoption->section);
16097 option->info = BYTE_GET (eoption->info);
16098
16099 /* PR 17531: file: ffa0fa3b. */
16100 if (option->size < sizeof (* eopt)
16101 || offset + option->size > sect->sh_size)
16102 {
16103 error (_("Invalid size (%u) for MIPS option\n"), option->size);
16104 return FALSE;
16105 }
16106 offset += option->size;
16107
16108 ++option;
16109 ++cnt;
16110 }
16111
16112 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16113 "\nSection '%s' contains %d entries:\n",
16114 cnt),
16115 printable_section_name (filedata, sect), cnt);
16116
16117 option = iopt;
16118 offset = 0;
16119
16120 while (cnt-- > 0)
16121 {
16122 size_t len;
16123
16124 switch (option->kind)
16125 {
16126 case ODK_NULL:
16127 /* This shouldn't happen. */
16128 printf (" NULL %d %lx", option->section, option->info);
16129 break;
16130 case ODK_REGINFO:
16131 printf (" REGINFO ");
16132 if (filedata->file_header.e_machine == EM_MIPS)
16133 {
16134 /* 32bit form. */
16135 Elf32_External_RegInfo * ereg;
16136 Elf32_RegInfo reginfo;
16137
16138 ereg = (Elf32_External_RegInfo *) (option + 1);
16139 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
16140 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16141 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16142 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16143 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16144 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
16145
16146 printf ("GPR %08lx GP 0x%lx\n",
16147 reginfo.ri_gprmask,
16148 (unsigned long) reginfo.ri_gp_value);
16149 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16150 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16151 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16152 }
16153 else
16154 {
16155 /* 64 bit form. */
16156 Elf64_External_RegInfo * ereg;
16157 Elf64_Internal_RegInfo reginfo;
16158
16159 ereg = (Elf64_External_RegInfo *) (option + 1);
16160 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
16161 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
16162 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
16163 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
16164 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
16165 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
16166
16167 printf ("GPR %08lx GP 0x",
16168 reginfo.ri_gprmask);
16169 printf_vma (reginfo.ri_gp_value);
16170 printf ("\n");
16171
16172 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16173 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
16174 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
16175 }
16176 ++option;
16177 continue;
16178 case ODK_EXCEPTIONS:
16179 fputs (" EXCEPTIONS fpe_min(", stdout);
16180 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
16181 fputs (") fpe_max(", stdout);
16182 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
16183 fputs (")", stdout);
16184
16185 if (option->info & OEX_PAGE0)
16186 fputs (" PAGE0", stdout);
16187 if (option->info & OEX_SMM)
16188 fputs (" SMM", stdout);
16189 if (option->info & OEX_FPDBUG)
16190 fputs (" FPDBUG", stdout);
16191 if (option->info & OEX_DISMISS)
16192 fputs (" DISMISS", stdout);
16193 break;
16194 case ODK_PAD:
16195 fputs (" PAD ", stdout);
16196 if (option->info & OPAD_PREFIX)
16197 fputs (" PREFIX", stdout);
16198 if (option->info & OPAD_POSTFIX)
16199 fputs (" POSTFIX", stdout);
16200 if (option->info & OPAD_SYMBOL)
16201 fputs (" SYMBOL", stdout);
16202 break;
16203 case ODK_HWPATCH:
16204 fputs (" HWPATCH ", stdout);
16205 if (option->info & OHW_R4KEOP)
16206 fputs (" R4KEOP", stdout);
16207 if (option->info & OHW_R8KPFETCH)
16208 fputs (" R8KPFETCH", stdout);
16209 if (option->info & OHW_R5KEOP)
16210 fputs (" R5KEOP", stdout);
16211 if (option->info & OHW_R5KCVTL)
16212 fputs (" R5KCVTL", stdout);
16213 break;
16214 case ODK_FILL:
16215 fputs (" FILL ", stdout);
16216 /* XXX Print content of info word? */
16217 break;
16218 case ODK_TAGS:
16219 fputs (" TAGS ", stdout);
16220 /* XXX Print content of info word? */
16221 break;
16222 case ODK_HWAND:
16223 fputs (" HWAND ", stdout);
16224 if (option->info & OHWA0_R4KEOP_CHECKED)
16225 fputs (" R4KEOP_CHECKED", stdout);
16226 if (option->info & OHWA0_R4KEOP_CLEAN)
16227 fputs (" R4KEOP_CLEAN", stdout);
16228 break;
16229 case ODK_HWOR:
16230 fputs (" HWOR ", stdout);
16231 if (option->info & OHWA0_R4KEOP_CHECKED)
16232 fputs (" R4KEOP_CHECKED", stdout);
16233 if (option->info & OHWA0_R4KEOP_CLEAN)
16234 fputs (" R4KEOP_CLEAN", stdout);
16235 break;
16236 case ODK_GP_GROUP:
16237 printf (" GP_GROUP %#06lx self-contained %#06lx",
16238 option->info & OGP_GROUP,
16239 (option->info & OGP_SELF) >> 16);
16240 break;
16241 case ODK_IDENT:
16242 printf (" IDENT %#06lx self-contained %#06lx",
16243 option->info & OGP_GROUP,
16244 (option->info & OGP_SELF) >> 16);
16245 break;
16246 default:
16247 /* This shouldn't happen. */
16248 printf (" %3d ??? %d %lx",
16249 option->kind, option->section, option->info);
16250 break;
16251 }
16252
16253 len = sizeof (* eopt);
16254 while (len < option->size)
16255 {
16256 unsigned char datum = * ((unsigned char *) eopt + offset + len);
16257
16258 if (ISPRINT (datum))
16259 printf ("%c", datum);
16260 else
16261 printf ("\\%03o", datum);
16262 len ++;
16263 }
16264 fputs ("\n", stdout);
16265
16266 offset += option->size;
16267 ++option;
16268 }
16269
16270 free (eopt);
16271 }
16272 else
16273 res = FALSE;
16274 }
16275
16276 if (conflicts_offset != 0 && conflictsno != 0)
16277 {
16278 Elf32_Conflict * iconf;
16279 size_t cnt;
16280
16281 if (dynamic_symbols == NULL)
16282 {
16283 error (_("conflict list found without a dynamic symbol table\n"));
16284 return FALSE;
16285 }
16286
16287 /* PR 21345 - print a slightly more helpful error message
16288 if we are sure that the cmalloc will fail. */
16289 if (conflictsno * sizeof (* iconf) > filedata->file_size)
16290 {
16291 error (_("Overlarge number of conflicts detected: %lx\n"),
16292 (long) conflictsno);
16293 return FALSE;
16294 }
16295
16296 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
16297 if (iconf == NULL)
16298 {
16299 error (_("Out of memory allocating space for dynamic conflicts\n"));
16300 return FALSE;
16301 }
16302
16303 if (is_32bit_elf)
16304 {
16305 Elf32_External_Conflict * econf32;
16306
16307 econf32 = (Elf32_External_Conflict *)
16308 get_data (NULL, filedata, conflicts_offset, conflictsno,
16309 sizeof (* econf32), _("conflict"));
16310 if (!econf32)
16311 return FALSE;
16312
16313 for (cnt = 0; cnt < conflictsno; ++cnt)
16314 iconf[cnt] = BYTE_GET (econf32[cnt]);
16315
16316 free (econf32);
16317 }
16318 else
16319 {
16320 Elf64_External_Conflict * econf64;
16321
16322 econf64 = (Elf64_External_Conflict *)
16323 get_data (NULL, filedata, conflicts_offset, conflictsno,
16324 sizeof (* econf64), _("conflict"));
16325 if (!econf64)
16326 return FALSE;
16327
16328 for (cnt = 0; cnt < conflictsno; ++cnt)
16329 iconf[cnt] = BYTE_GET (econf64[cnt]);
16330
16331 free (econf64);
16332 }
16333
16334 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16335 "\nSection '.conflict' contains %lu entries:\n",
16336 (unsigned long) conflictsno),
16337 (unsigned long) conflictsno);
16338 puts (_(" Num: Index Value Name"));
16339
16340 for (cnt = 0; cnt < conflictsno; ++cnt)
16341 {
16342 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
16343
16344 if (iconf[cnt] >= num_dynamic_syms)
16345 printf (_("<corrupt symbol index>"));
16346 else
16347 {
16348 Elf_Internal_Sym * psym;
16349
16350 psym = & dynamic_symbols[iconf[cnt]];
16351 print_vma (psym->st_value, FULL_HEX);
16352 putchar (' ');
16353 if (VALID_DYNAMIC_NAME (psym->st_name))
16354 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
16355 else
16356 printf (_("<corrupt: %14ld>"), psym->st_name);
16357 }
16358 putchar ('\n');
16359 }
16360
16361 free (iconf);
16362 }
16363
16364 if (pltgot != 0 && local_gotno != 0)
16365 {
16366 bfd_vma ent, local_end, global_end;
16367 size_t i, offset;
16368 unsigned char * data;
16369 unsigned char * data_end;
16370 int addr_size;
16371
16372 ent = pltgot;
16373 addr_size = (is_32bit_elf ? 4 : 8);
16374 local_end = pltgot + local_gotno * addr_size;
16375
16376 /* PR binutils/17533 file: 012-111227-0.004 */
16377 if (symtabno < gotsym)
16378 {
16379 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16380 (unsigned long) gotsym, (unsigned long) symtabno);
16381 return FALSE;
16382 }
16383
16384 global_end = local_end + (symtabno - gotsym) * addr_size;
16385 /* PR 17531: file: 54c91a34. */
16386 if (global_end < local_end)
16387 {
16388 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
16389 return FALSE;
16390 }
16391
16392 offset = offset_from_vma (filedata, pltgot, global_end - pltgot);
16393 data = (unsigned char *) get_data (NULL, filedata, offset,
16394 global_end - pltgot, 1,
16395 _("Global Offset Table data"));
16396 /* PR 12855: Null data is handled gracefully throughout. */
16397 data_end = data + (global_end - pltgot);
16398
16399 printf (_("\nPrimary GOT:\n"));
16400 printf (_(" Canonical gp value: "));
16401 print_vma (pltgot + 0x7ff0, LONG_HEX);
16402 printf ("\n\n");
16403
16404 printf (_(" Reserved entries:\n"));
16405 printf (_(" %*s %10s %*s Purpose\n"),
16406 addr_size * 2, _("Address"), _("Access"),
16407 addr_size * 2, _("Initial"));
16408 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16409 printf (_(" Lazy resolver\n"));
16410 if (ent == (bfd_vma) -1)
16411 goto got_print_fail;
16412
16413 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16414 This entry will be used by some runtime loaders, to store the
16415 module pointer. Otherwise this is an ordinary local entry.
16416 PR 21344: Check for the entry being fully available before
16417 fetching it. */
16418 if (data
16419 && data + ent - pltgot + addr_size <= data_end
16420 && (byte_get (data + ent - pltgot, addr_size)
16421 >> (addr_size * 8 - 1)) != 0)
16422 {
16423 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16424 printf (_(" Module pointer (GNU extension)\n"));
16425 if (ent == (bfd_vma) -1)
16426 goto got_print_fail;
16427 }
16428 printf ("\n");
16429
16430 if (data != NULL && ent < local_end)
16431 {
16432 printf (_(" Local entries:\n"));
16433 printf (" %*s %10s %*s\n",
16434 addr_size * 2, _("Address"), _("Access"),
16435 addr_size * 2, _("Initial"));
16436 while (ent < local_end)
16437 {
16438 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16439 printf ("\n");
16440 if (ent == (bfd_vma) -1)
16441 goto got_print_fail;
16442 }
16443 printf ("\n");
16444 }
16445
16446 if (data != NULL && gotsym < symtabno)
16447 {
16448 int sym_width;
16449
16450 printf (_(" Global entries:\n"));
16451 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
16452 addr_size * 2, _("Address"),
16453 _("Access"),
16454 addr_size * 2, _("Initial"),
16455 addr_size * 2, _("Sym.Val."),
16456 _("Type"),
16457 /* Note for translators: "Ndx" = abbreviated form of "Index". */
16458 _("Ndx"), _("Name"));
16459
16460 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
16461
16462 for (i = gotsym; i < symtabno; i++)
16463 {
16464 ent = print_mips_got_entry (data, pltgot, ent, data_end);
16465 printf (" ");
16466
16467 if (dynamic_symbols == NULL)
16468 printf (_("<no dynamic symbols>"));
16469 else if (i < num_dynamic_syms)
16470 {
16471 Elf_Internal_Sym * psym = dynamic_symbols + i;
16472
16473 print_vma (psym->st_value, LONG_HEX);
16474 printf (" %-7s %3s ",
16475 get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16476 get_symbol_index_type (filedata, psym->st_shndx));
16477
16478 if (VALID_DYNAMIC_NAME (psym->st_name))
16479 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16480 else
16481 printf (_("<corrupt: %14ld>"), psym->st_name);
16482 }
16483 else
16484 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16485 (unsigned long) i);
16486
16487 printf ("\n");
16488 if (ent == (bfd_vma) -1)
16489 break;
16490 }
16491 printf ("\n");
16492 }
16493
16494 got_print_fail:
16495 if (data)
16496 free (data);
16497 }
16498
16499 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
16500 {
16501 bfd_vma ent, end;
16502 size_t offset, rel_offset;
16503 unsigned long count, i;
16504 unsigned char * data;
16505 int addr_size, sym_width;
16506 Elf_Internal_Rela * rels;
16507
16508 rel_offset = offset_from_vma (filedata, jmprel, pltrelsz);
16509 if (pltrel == DT_RELA)
16510 {
16511 if (!slurp_rela_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16512 return FALSE;
16513 }
16514 else
16515 {
16516 if (!slurp_rel_relocs (filedata, rel_offset, pltrelsz, &rels, &count))
16517 return FALSE;
16518 }
16519
16520 ent = mips_pltgot;
16521 addr_size = (is_32bit_elf ? 4 : 8);
16522 end = mips_pltgot + (2 + count) * addr_size;
16523
16524 offset = offset_from_vma (filedata, mips_pltgot, end - mips_pltgot);
16525 data = (unsigned char *) get_data (NULL, filedata, offset, end - mips_pltgot,
16526 1, _("Procedure Linkage Table data"));
16527 if (data == NULL)
16528 return FALSE;
16529
16530 printf ("\nPLT GOT:\n\n");
16531 printf (_(" Reserved entries:\n"));
16532 printf (_(" %*s %*s Purpose\n"),
16533 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
16534 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16535 printf (_(" PLT lazy resolver\n"));
16536 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16537 printf (_(" Module pointer\n"));
16538 printf ("\n");
16539
16540 printf (_(" Entries:\n"));
16541 printf (" %*s %*s %*s %-7s %3s %s\n",
16542 addr_size * 2, _("Address"),
16543 addr_size * 2, _("Initial"),
16544 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16545 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
16546 for (i = 0; i < count; i++)
16547 {
16548 unsigned long idx = get_reloc_symindex (rels[i].r_info);
16549
16550 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
16551 printf (" ");
16552
16553 if (idx >= num_dynamic_syms)
16554 printf (_("<corrupt symbol index: %lu>"), idx);
16555 else
16556 {
16557 Elf_Internal_Sym * psym = dynamic_symbols + idx;
16558
16559 print_vma (psym->st_value, LONG_HEX);
16560 printf (" %-7s %3s ",
16561 get_symbol_type (filedata, ELF_ST_TYPE (psym->st_info)),
16562 get_symbol_index_type (filedata, psym->st_shndx));
16563 if (VALID_DYNAMIC_NAME (psym->st_name))
16564 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
16565 else
16566 printf (_("<corrupt: %14ld>"), psym->st_name);
16567 }
16568 printf ("\n");
16569 }
16570 printf ("\n");
16571
16572 if (data)
16573 free (data);
16574 free (rels);
16575 }
16576
16577 return res;
16578 }
16579
16580 static bfd_boolean
16581 process_nds32_specific (Filedata * filedata)
16582 {
16583 Elf_Internal_Shdr *sect = NULL;
16584
16585 sect = find_section (filedata, ".nds32_e_flags");
16586 if (sect != NULL)
16587 {
16588 unsigned int *flag;
16589
16590 printf ("\nNDS32 elf flags section:\n");
16591 flag = get_data (NULL, filedata, sect->sh_offset, 1,
16592 sect->sh_size, _("NDS32 elf flags section"));
16593
16594 if (! flag)
16595 return FALSE;
16596
16597 switch ((*flag) & 0x3)
16598 {
16599 case 0:
16600 printf ("(VEC_SIZE):\tNo entry.\n");
16601 break;
16602 case 1:
16603 printf ("(VEC_SIZE):\t4 bytes\n");
16604 break;
16605 case 2:
16606 printf ("(VEC_SIZE):\t16 bytes\n");
16607 break;
16608 case 3:
16609 printf ("(VEC_SIZE):\treserved\n");
16610 break;
16611 }
16612 }
16613
16614 return TRUE;
16615 }
16616
16617 static bfd_boolean
16618 process_gnu_liblist (Filedata * filedata)
16619 {
16620 Elf_Internal_Shdr * section;
16621 Elf_Internal_Shdr * string_sec;
16622 Elf32_External_Lib * elib;
16623 char * strtab;
16624 size_t strtab_size;
16625 size_t cnt;
16626 unsigned long num_liblist;
16627 unsigned i;
16628 bfd_boolean res = TRUE;
16629
16630 if (! do_arch)
16631 return TRUE;
16632
16633 for (i = 0, section = filedata->section_headers;
16634 i < filedata->file_header.e_shnum;
16635 i++, section++)
16636 {
16637 switch (section->sh_type)
16638 {
16639 case SHT_GNU_LIBLIST:
16640 if (section->sh_link >= filedata->file_header.e_shnum)
16641 break;
16642
16643 elib = (Elf32_External_Lib *)
16644 get_data (NULL, filedata, section->sh_offset, 1, section->sh_size,
16645 _("liblist section data"));
16646
16647 if (elib == NULL)
16648 {
16649 res = FALSE;
16650 break;
16651 }
16652
16653 string_sec = filedata->section_headers + section->sh_link;
16654 strtab = (char *) get_data (NULL, filedata, string_sec->sh_offset, 1,
16655 string_sec->sh_size,
16656 _("liblist string table"));
16657 if (strtab == NULL
16658 || section->sh_entsize != sizeof (Elf32_External_Lib))
16659 {
16660 free (elib);
16661 free (strtab);
16662 res = FALSE;
16663 break;
16664 }
16665 strtab_size = string_sec->sh_size;
16666
16667 num_liblist = section->sh_size / sizeof (Elf32_External_Lib);
16668 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
16669 "\nLibrary list section '%s' contains %lu entries:\n",
16670 num_liblist),
16671 printable_section_name (filedata, section),
16672 num_liblist);
16673
16674 puts (_(" Library Time Stamp Checksum Version Flags"));
16675
16676 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
16677 ++cnt)
16678 {
16679 Elf32_Lib liblist;
16680 time_t atime;
16681 char timebuf[128];
16682 struct tm * tmp;
16683
16684 liblist.l_name = BYTE_GET (elib[cnt].l_name);
16685 atime = BYTE_GET (elib[cnt].l_time_stamp);
16686 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
16687 liblist.l_version = BYTE_GET (elib[cnt].l_version);
16688 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
16689
16690 tmp = gmtime (&atime);
16691 snprintf (timebuf, sizeof (timebuf),
16692 "%04u-%02u-%02uT%02u:%02u:%02u",
16693 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
16694 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
16695
16696 printf ("%3lu: ", (unsigned long) cnt);
16697 if (do_wide)
16698 printf ("%-20s", liblist.l_name < strtab_size
16699 ? strtab + liblist.l_name : _("<corrupt>"));
16700 else
16701 printf ("%-20.20s", liblist.l_name < strtab_size
16702 ? strtab + liblist.l_name : _("<corrupt>"));
16703 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
16704 liblist.l_version, liblist.l_flags);
16705 }
16706
16707 free (elib);
16708 free (strtab);
16709 }
16710 }
16711
16712 return res;
16713 }
16714
16715 static const char *
16716 get_note_type (Filedata * filedata, unsigned e_type)
16717 {
16718 static char buff[64];
16719
16720 if (filedata->file_header.e_type == ET_CORE)
16721 switch (e_type)
16722 {
16723 case NT_AUXV:
16724 return _("NT_AUXV (auxiliary vector)");
16725 case NT_PRSTATUS:
16726 return _("NT_PRSTATUS (prstatus structure)");
16727 case NT_FPREGSET:
16728 return _("NT_FPREGSET (floating point registers)");
16729 case NT_PRPSINFO:
16730 return _("NT_PRPSINFO (prpsinfo structure)");
16731 case NT_TASKSTRUCT:
16732 return _("NT_TASKSTRUCT (task structure)");
16733 case NT_PRXFPREG:
16734 return _("NT_PRXFPREG (user_xfpregs structure)");
16735 case NT_PPC_VMX:
16736 return _("NT_PPC_VMX (ppc Altivec registers)");
16737 case NT_PPC_VSX:
16738 return _("NT_PPC_VSX (ppc VSX registers)");
16739 case NT_PPC_TAR:
16740 return _("NT_PPC_TAR (ppc TAR register)");
16741 case NT_PPC_PPR:
16742 return _("NT_PPC_PPR (ppc PPR register)");
16743 case NT_PPC_DSCR:
16744 return _("NT_PPC_DSCR (ppc DSCR register)");
16745 case NT_PPC_EBB:
16746 return _("NT_PPC_EBB (ppc EBB registers)");
16747 case NT_PPC_PMU:
16748 return _("NT_PPC_PMU (ppc PMU registers)");
16749 case NT_PPC_TM_CGPR:
16750 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16751 case NT_PPC_TM_CFPR:
16752 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16753 case NT_PPC_TM_CVMX:
16754 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16755 case NT_PPC_TM_CVSX:
16756 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
16757 case NT_PPC_TM_SPR:
16758 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16759 case NT_PPC_TM_CTAR:
16760 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16761 case NT_PPC_TM_CPPR:
16762 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16763 case NT_PPC_TM_CDSCR:
16764 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16765 case NT_386_TLS:
16766 return _("NT_386_TLS (x86 TLS information)");
16767 case NT_386_IOPERM:
16768 return _("NT_386_IOPERM (x86 I/O permissions)");
16769 case NT_X86_XSTATE:
16770 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16771 case NT_S390_HIGH_GPRS:
16772 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16773 case NT_S390_TIMER:
16774 return _("NT_S390_TIMER (s390 timer register)");
16775 case NT_S390_TODCMP:
16776 return _("NT_S390_TODCMP (s390 TOD comparator register)");
16777 case NT_S390_TODPREG:
16778 return _("NT_S390_TODPREG (s390 TOD programmable register)");
16779 case NT_S390_CTRS:
16780 return _("NT_S390_CTRS (s390 control registers)");
16781 case NT_S390_PREFIX:
16782 return _("NT_S390_PREFIX (s390 prefix register)");
16783 case NT_S390_LAST_BREAK:
16784 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16785 case NT_S390_SYSTEM_CALL:
16786 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16787 case NT_S390_TDB:
16788 return _("NT_S390_TDB (s390 transaction diagnostic block)");
16789 case NT_S390_VXRS_LOW:
16790 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16791 case NT_S390_VXRS_HIGH:
16792 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16793 case NT_S390_GS_CB:
16794 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16795 case NT_S390_GS_BC:
16796 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16797 case NT_ARM_VFP:
16798 return _("NT_ARM_VFP (arm VFP registers)");
16799 case NT_ARM_TLS:
16800 return _("NT_ARM_TLS (AArch TLS registers)");
16801 case NT_ARM_HW_BREAK:
16802 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16803 case NT_ARM_HW_WATCH:
16804 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16805 case NT_PSTATUS:
16806 return _("NT_PSTATUS (pstatus structure)");
16807 case NT_FPREGS:
16808 return _("NT_FPREGS (floating point registers)");
16809 case NT_PSINFO:
16810 return _("NT_PSINFO (psinfo structure)");
16811 case NT_LWPSTATUS:
16812 return _("NT_LWPSTATUS (lwpstatus_t structure)");
16813 case NT_LWPSINFO:
16814 return _("NT_LWPSINFO (lwpsinfo_t structure)");
16815 case NT_WIN32PSTATUS:
16816 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16817 case NT_SIGINFO:
16818 return _("NT_SIGINFO (siginfo_t data)");
16819 case NT_FILE:
16820 return _("NT_FILE (mapped files)");
16821 default:
16822 break;
16823 }
16824 else
16825 switch (e_type)
16826 {
16827 case NT_VERSION:
16828 return _("NT_VERSION (version)");
16829 case NT_ARCH:
16830 return _("NT_ARCH (architecture)");
16831 case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16832 return _("OPEN");
16833 case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16834 return _("func");
16835 default:
16836 break;
16837 }
16838
16839 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16840 return buff;
16841 }
16842
16843 static bfd_boolean
16844 print_core_note (Elf_Internal_Note *pnote)
16845 {
16846 unsigned int addr_size = is_32bit_elf ? 4 : 8;
16847 bfd_vma count, page_size;
16848 unsigned char *descdata, *filenames, *descend;
16849
16850 if (pnote->type != NT_FILE)
16851 {
16852 if (do_wide)
16853 printf ("\n");
16854 return TRUE;
16855 }
16856
16857 #ifndef BFD64
16858 if (!is_32bit_elf)
16859 {
16860 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
16861 /* Still "successful". */
16862 return TRUE;
16863 }
16864 #endif
16865
16866 if (pnote->descsz < 2 * addr_size)
16867 {
16868 error (_(" Malformed note - too short for header\n"));
16869 return FALSE;
16870 }
16871
16872 descdata = (unsigned char *) pnote->descdata;
16873 descend = descdata + pnote->descsz;
16874
16875 if (descdata[pnote->descsz - 1] != '\0')
16876 {
16877 error (_(" Malformed note - does not end with \\0\n"));
16878 return FALSE;
16879 }
16880
16881 count = byte_get (descdata, addr_size);
16882 descdata += addr_size;
16883
16884 page_size = byte_get (descdata, addr_size);
16885 descdata += addr_size;
16886
16887 if (count > ((bfd_vma) -1 - 2 * addr_size) / (3 * addr_size)
16888 || pnote->descsz < 2 * addr_size + count * 3 * addr_size)
16889 {
16890 error (_(" Malformed note - too short for supplied file count\n"));
16891 return FALSE;
16892 }
16893
16894 printf (_(" Page size: "));
16895 print_vma (page_size, DEC);
16896 printf ("\n");
16897
16898 printf (_(" %*s%*s%*s\n"),
16899 (int) (2 + 2 * addr_size), _("Start"),
16900 (int) (4 + 2 * addr_size), _("End"),
16901 (int) (4 + 2 * addr_size), _("Page Offset"));
16902 filenames = descdata + count * 3 * addr_size;
16903 while (count-- > 0)
16904 {
16905 bfd_vma start, end, file_ofs;
16906
16907 if (filenames == descend)
16908 {
16909 error (_(" Malformed note - filenames end too early\n"));
16910 return FALSE;
16911 }
16912
16913 start = byte_get (descdata, addr_size);
16914 descdata += addr_size;
16915 end = byte_get (descdata, addr_size);
16916 descdata += addr_size;
16917 file_ofs = byte_get (descdata, addr_size);
16918 descdata += addr_size;
16919
16920 printf (" ");
16921 print_vma (start, FULL_HEX);
16922 printf (" ");
16923 print_vma (end, FULL_HEX);
16924 printf (" ");
16925 print_vma (file_ofs, FULL_HEX);
16926 printf ("\n %s\n", filenames);
16927
16928 filenames += 1 + strlen ((char *) filenames);
16929 }
16930
16931 return TRUE;
16932 }
16933
16934 static const char *
16935 get_gnu_elf_note_type (unsigned e_type)
16936 {
16937 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
16938 switch (e_type)
16939 {
16940 case NT_GNU_ABI_TAG:
16941 return _("NT_GNU_ABI_TAG (ABI version tag)");
16942 case NT_GNU_HWCAP:
16943 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16944 case NT_GNU_BUILD_ID:
16945 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16946 case NT_GNU_GOLD_VERSION:
16947 return _("NT_GNU_GOLD_VERSION (gold version)");
16948 case NT_GNU_PROPERTY_TYPE_0:
16949 return _("NT_GNU_PROPERTY_TYPE_0");
16950 case NT_GNU_BUILD_ATTRIBUTE_OPEN:
16951 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16952 case NT_GNU_BUILD_ATTRIBUTE_FUNC:
16953 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16954 default:
16955 {
16956 static char buff[64];
16957
16958 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16959 return buff;
16960 }
16961 }
16962 }
16963
16964 static void
16965 decode_x86_compat_isa (unsigned int bitmask)
16966 {
16967 while (bitmask)
16968 {
16969 unsigned int bit = bitmask & (- bitmask);
16970
16971 bitmask &= ~ bit;
16972 switch (bit)
16973 {
16974 case GNU_PROPERTY_X86_COMPAT_ISA_1_486:
16975 printf ("i486");
16976 break;
16977 case GNU_PROPERTY_X86_COMPAT_ISA_1_586:
16978 printf ("586");
16979 break;
16980 case GNU_PROPERTY_X86_COMPAT_ISA_1_686:
16981 printf ("686");
16982 break;
16983 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE:
16984 printf ("SSE");
16985 break;
16986 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2:
16987 printf ("SSE2");
16988 break;
16989 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3:
16990 printf ("SSE3");
16991 break;
16992 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3:
16993 printf ("SSSE3");
16994 break;
16995 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1:
16996 printf ("SSE4_1");
16997 break;
16998 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2:
16999 printf ("SSE4_2");
17000 break;
17001 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX:
17002 printf ("AVX");
17003 break;
17004 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2:
17005 printf ("AVX2");
17006 break;
17007 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F:
17008 printf ("AVX512F");
17009 break;
17010 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD:
17011 printf ("AVX512CD");
17012 break;
17013 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER:
17014 printf ("AVX512ER");
17015 break;
17016 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF:
17017 printf ("AVX512PF");
17018 break;
17019 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL:
17020 printf ("AVX512VL");
17021 break;
17022 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ:
17023 printf ("AVX512DQ");
17024 break;
17025 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW:
17026 printf ("AVX512BW");
17027 break;
17028 default:
17029 printf (_("<unknown: %x>"), bit);
17030 break;
17031 }
17032 if (bitmask)
17033 printf (", ");
17034 }
17035 }
17036
17037 static void
17038 decode_x86_isa (unsigned int bitmask)
17039 {
17040 if (bitmask == GNU_PROPERTY_X86_UINT32_VALID)
17041 {
17042 printf (_("<None>"));
17043 return;
17044 }
17045 else
17046 bitmask &= ~GNU_PROPERTY_X86_UINT32_VALID;
17047
17048 while (bitmask)
17049 {
17050 unsigned int bit = bitmask & (- bitmask);
17051
17052 bitmask &= ~ bit;
17053 switch (bit)
17054 {
17055 case GNU_PROPERTY_X86_ISA_1_CMOV:
17056 printf ("CMOV");
17057 break;
17058 case GNU_PROPERTY_X86_ISA_1_SSE:
17059 printf ("SSE");
17060 break;
17061 case GNU_PROPERTY_X86_ISA_1_SSE2:
17062 printf ("SSE2");
17063 break;
17064 case GNU_PROPERTY_X86_ISA_1_SSE3:
17065 printf ("SSE3");
17066 break;
17067 case GNU_PROPERTY_X86_ISA_1_SSSE3:
17068 printf ("SSSE3");
17069 break;
17070 case GNU_PROPERTY_X86_ISA_1_SSE4_1:
17071 printf ("SSE4_1");
17072 break;
17073 case GNU_PROPERTY_X86_ISA_1_SSE4_2:
17074 printf ("SSE4_2");
17075 break;
17076 case GNU_PROPERTY_X86_ISA_1_AVX:
17077 printf ("AVX");
17078 break;
17079 case GNU_PROPERTY_X86_ISA_1_AVX2:
17080 printf ("AVX2");
17081 break;
17082 case GNU_PROPERTY_X86_ISA_1_FMA:
17083 printf ("FMA");
17084 break;
17085 case GNU_PROPERTY_X86_ISA_1_AVX512F:
17086 printf ("AVX512F");
17087 break;
17088 case GNU_PROPERTY_X86_ISA_1_AVX512CD:
17089 printf ("AVX512CD");
17090 break;
17091 case GNU_PROPERTY_X86_ISA_1_AVX512ER:
17092 printf ("AVX512ER");
17093 break;
17094 case GNU_PROPERTY_X86_ISA_1_AVX512PF:
17095 printf ("AVX512PF");
17096 break;
17097 case GNU_PROPERTY_X86_ISA_1_AVX512VL:
17098 printf ("AVX512VL");
17099 break;
17100 case GNU_PROPERTY_X86_ISA_1_AVX512DQ:
17101 printf ("AVX512DQ");
17102 break;
17103 case GNU_PROPERTY_X86_ISA_1_AVX512BW:
17104 printf ("AVX512BW");
17105 break;
17106 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS:
17107 printf ("AVX512_4FMAPS");
17108 break;
17109 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW:
17110 printf ("AVX512_4VNNIW");
17111 break;
17112 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG:
17113 printf ("AVX512_BITALG");
17114 break;
17115 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA:
17116 printf ("AVX512_IFMA");
17117 break;
17118 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI:
17119 printf ("AVX512_VBMI");
17120 break;
17121 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2:
17122 printf ("AVX512_VBMI2");
17123 break;
17124 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI:
17125 printf ("AVX512_VNNI");
17126 break;
17127 default:
17128 printf (_("<unknown: %x>"), bit);
17129 break;
17130 }
17131 if (bitmask)
17132 printf (", ");
17133 }
17134 }
17135
17136 static void
17137 decode_x86_feature_1 (unsigned int bitmask)
17138 {
17139 if (bitmask == GNU_PROPERTY_X86_UINT32_VALID)
17140 {
17141 printf (_("<None>"));
17142 return;
17143 }
17144 else
17145 bitmask &= ~GNU_PROPERTY_X86_UINT32_VALID;
17146
17147 while (bitmask)
17148 {
17149 unsigned int bit = bitmask & (- bitmask);
17150
17151 bitmask &= ~ bit;
17152 switch (bit)
17153 {
17154 case GNU_PROPERTY_X86_FEATURE_1_IBT:
17155 printf ("IBT");
17156 break;
17157 case GNU_PROPERTY_X86_FEATURE_1_SHSTK:
17158 printf ("SHSTK");
17159 break;
17160 default:
17161 printf (_("<unknown: %x>"), bit);
17162 break;
17163 }
17164 if (bitmask)
17165 printf (", ");
17166 }
17167 }
17168
17169 static void
17170 decode_x86_feature_2 (unsigned int bitmask)
17171 {
17172 if (bitmask == GNU_PROPERTY_X86_UINT32_VALID)
17173 {
17174 printf (_("<None>"));
17175 return;
17176 }
17177 else
17178 bitmask &= ~GNU_PROPERTY_X86_UINT32_VALID;
17179
17180 while (bitmask)
17181 {
17182 unsigned int bit = bitmask & (- bitmask);
17183
17184 bitmask &= ~ bit;
17185 switch (bit)
17186 {
17187 case GNU_PROPERTY_X86_FEATURE_2_X86:
17188 printf ("x86");
17189 break;
17190 case GNU_PROPERTY_X86_FEATURE_2_X87:
17191 printf ("x87");
17192 break;
17193 case GNU_PROPERTY_X86_FEATURE_2_MMX:
17194 printf ("MMX");
17195 break;
17196 case GNU_PROPERTY_X86_FEATURE_2_XMM:
17197 printf ("XMM");
17198 break;
17199 case GNU_PROPERTY_X86_FEATURE_2_YMM:
17200 printf ("YMM");
17201 break;
17202 case GNU_PROPERTY_X86_FEATURE_2_ZMM:
17203 printf ("ZMM");
17204 break;
17205 case GNU_PROPERTY_X86_FEATURE_2_FXSR:
17206 printf ("FXSR");
17207 break;
17208 case GNU_PROPERTY_X86_FEATURE_2_XSAVE:
17209 printf ("XSAVE");
17210 break;
17211 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT:
17212 printf ("XSAVEOPT");
17213 break;
17214 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC:
17215 printf ("XSAVEC");
17216 break;
17217 default:
17218 printf (_("<unknown: %x>"), bit);
17219 break;
17220 }
17221 if (bitmask)
17222 printf (", ");
17223 }
17224 }
17225
17226 static void
17227 print_gnu_property_note (Filedata * filedata, Elf_Internal_Note * pnote)
17228 {
17229 unsigned char * ptr = (unsigned char *) pnote->descdata;
17230 unsigned char * ptr_end = ptr + pnote->descsz;
17231 unsigned int size = is_32bit_elf ? 4 : 8;
17232
17233 printf (_(" Properties: "));
17234
17235 if (pnote->descsz < 8 || (pnote->descsz % size) != 0)
17236 {
17237 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
17238 return;
17239 }
17240
17241 while (ptr < ptr_end)
17242 {
17243 unsigned int j;
17244 unsigned int type;
17245 unsigned int datasz;
17246
17247 if ((size_t) (ptr_end - ptr) < 8)
17248 {
17249 printf (_("<corrupt descsz: %#lx>\n"), pnote->descsz);
17250 break;
17251 }
17252
17253 type = byte_get (ptr, 4);
17254 datasz = byte_get (ptr + 4, 4);
17255
17256 ptr += 8;
17257
17258 if (datasz > (size_t) (ptr_end - ptr))
17259 {
17260 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
17261 type, datasz);
17262 break;
17263 }
17264
17265 if (type >= GNU_PROPERTY_LOPROC && type <= GNU_PROPERTY_HIPROC)
17266 {
17267 if (filedata->file_header.e_machine == EM_X86_64
17268 || filedata->file_header.e_machine == EM_IAMCU
17269 || filedata->file_header.e_machine == EM_386)
17270 {
17271 unsigned int bitmask;
17272
17273 if (datasz == 4)
17274 {
17275 bitmask = byte_get (ptr, 4);
17276 if ((filedata->file_header.e_type == ET_EXEC
17277 || filedata->file_header.e_type == ET_DYN)
17278 && !(bitmask & GNU_PROPERTY_X86_UINT32_VALID))
17279 printf ("Invalid ");
17280 }
17281 else
17282 bitmask = 0;
17283
17284 switch (type)
17285 {
17286 case GNU_PROPERTY_X86_ISA_1_USED:
17287 if (datasz != 4)
17288 printf (_("x86 ISA used: <corrupt length: %#x> "),
17289 datasz);
17290 else
17291 {
17292 printf ("x86 ISA used: ");
17293 decode_x86_isa (bitmask);
17294 }
17295 goto next;
17296
17297 case GNU_PROPERTY_X86_ISA_1_NEEDED:
17298 if (datasz != 4)
17299 printf (_("x86 ISA needed: <corrupt length: %#x> "),
17300 datasz);
17301 else
17302 {
17303 printf ("x86 ISA needed: ");
17304 decode_x86_isa (bitmask);
17305 }
17306 goto next;
17307
17308 case GNU_PROPERTY_X86_FEATURE_1_AND:
17309 if (datasz != 4)
17310 printf (_("x86 feature: <corrupt length: %#x> "),
17311 datasz);
17312 else
17313 {
17314 printf ("x86 feature: ");
17315 decode_x86_feature_1 (bitmask);
17316 }
17317 goto next;
17318
17319 case GNU_PROPERTY_X86_FEATURE_2_USED:
17320 if (datasz != 4)
17321 printf (_("x86 feature used: <corrupt length: %#x> "),
17322 datasz);
17323 else
17324 {
17325 printf ("x86 feature used: ");
17326 decode_x86_feature_2 (bitmask);
17327 }
17328 goto next;
17329
17330 case GNU_PROPERTY_X86_FEATURE_2_NEEDED:
17331 if (datasz != 4)
17332 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz);
17333 else
17334 {
17335 printf ("x86 feature needed: ");
17336 decode_x86_feature_2 (bitmask);
17337 }
17338 goto next;
17339
17340 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED:
17341 if (datasz != 4)
17342 printf (_("x86 ISA used: <corrupt length: %#x> "),
17343 datasz);
17344 else
17345 {
17346 printf ("x86 ISA used: ");
17347 decode_x86_compat_isa (bitmask);
17348 }
17349 goto next;
17350
17351 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED:
17352 if (datasz != 4)
17353 printf (_("x86 ISA needed: <corrupt length: %#x> "),
17354 datasz);
17355 else
17356 {
17357 printf ("x86 ISA needed: ");
17358 decode_x86_compat_isa (bitmask);
17359 }
17360 goto next;
17361
17362 default:
17363 break;
17364 }
17365 }
17366 }
17367 else
17368 {
17369 switch (type)
17370 {
17371 case GNU_PROPERTY_STACK_SIZE:
17372 printf (_("stack size: "));
17373 if (datasz != size)
17374 printf (_("<corrupt length: %#x> "), datasz);
17375 else
17376 printf ("%#lx", (unsigned long) byte_get (ptr, size));
17377 goto next;
17378
17379 case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
17380 printf ("no copy on protected ");
17381 if (datasz)
17382 printf (_("<corrupt length: %#x> "), datasz);
17383 goto next;
17384
17385 default:
17386 break;
17387 }
17388 }
17389
17390 if (type < GNU_PROPERTY_LOPROC)
17391 printf (_("<unknown type %#x data: "), type);
17392 else if (type < GNU_PROPERTY_LOUSER)
17393 printf (_("<procesor-specific type %#x data: "), type);
17394 else
17395 printf (_("<application-specific type %#x data: "), type);
17396 for (j = 0; j < datasz; ++j)
17397 printf ("%02x ", ptr[j] & 0xff);
17398 printf (">");
17399
17400 next:
17401 ptr += ((datasz + (size - 1)) & ~ (size - 1));
17402 if (ptr == ptr_end)
17403 break;
17404
17405 if (do_wide)
17406 printf (", ");
17407 else
17408 printf ("\n\t");
17409 }
17410
17411 printf ("\n");
17412 }
17413
17414 static bfd_boolean
17415 print_gnu_note (Filedata * filedata, Elf_Internal_Note *pnote)
17416 {
17417 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
17418 switch (pnote->type)
17419 {
17420 case NT_GNU_BUILD_ID:
17421 {
17422 unsigned long i;
17423
17424 printf (_(" Build ID: "));
17425 for (i = 0; i < pnote->descsz; ++i)
17426 printf ("%02x", pnote->descdata[i] & 0xff);
17427 printf ("\n");
17428 }
17429 break;
17430
17431 case NT_GNU_ABI_TAG:
17432 {
17433 unsigned long os, major, minor, subminor;
17434 const char *osname;
17435
17436 /* PR 17531: file: 030-599401-0.004. */
17437 if (pnote->descsz < 16)
17438 {
17439 printf (_(" <corrupt GNU_ABI_TAG>\n"));
17440 break;
17441 }
17442
17443 os = byte_get ((unsigned char *) pnote->descdata, 4);
17444 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17445 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
17446 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
17447
17448 switch (os)
17449 {
17450 case GNU_ABI_TAG_LINUX:
17451 osname = "Linux";
17452 break;
17453 case GNU_ABI_TAG_HURD:
17454 osname = "Hurd";
17455 break;
17456 case GNU_ABI_TAG_SOLARIS:
17457 osname = "Solaris";
17458 break;
17459 case GNU_ABI_TAG_FREEBSD:
17460 osname = "FreeBSD";
17461 break;
17462 case GNU_ABI_TAG_NETBSD:
17463 osname = "NetBSD";
17464 break;
17465 case GNU_ABI_TAG_SYLLABLE:
17466 osname = "Syllable";
17467 break;
17468 case GNU_ABI_TAG_NACL:
17469 osname = "NaCl";
17470 break;
17471 default:
17472 osname = "Unknown";
17473 break;
17474 }
17475
17476 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
17477 major, minor, subminor);
17478 }
17479 break;
17480
17481 case NT_GNU_GOLD_VERSION:
17482 {
17483 unsigned long i;
17484
17485 printf (_(" Version: "));
17486 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
17487 printf ("%c", pnote->descdata[i]);
17488 printf ("\n");
17489 }
17490 break;
17491
17492 case NT_GNU_HWCAP:
17493 {
17494 unsigned long num_entries, mask;
17495
17496 /* Hardware capabilities information. Word 0 is the number of entries.
17497 Word 1 is a bitmask of enabled entries. The rest of the descriptor
17498 is a series of entries, where each entry is a single byte followed
17499 by a nul terminated string. The byte gives the bit number to test
17500 if enabled in the bitmask. */
17501 printf (_(" Hardware Capabilities: "));
17502 if (pnote->descsz < 8)
17503 {
17504 error (_("<corrupt GNU_HWCAP>\n"));
17505 return FALSE;
17506 }
17507 num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
17508 mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
17509 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
17510 /* FIXME: Add code to display the entries... */
17511 }
17512 break;
17513
17514 case NT_GNU_PROPERTY_TYPE_0:
17515 print_gnu_property_note (filedata, pnote);
17516 break;
17517
17518 default:
17519 /* Handle unrecognised types. An error message should have already been
17520 created by get_gnu_elf_note_type(), so all that we need to do is to
17521 display the data. */
17522 {
17523 unsigned long i;
17524
17525 printf (_(" Description data: "));
17526 for (i = 0; i < pnote->descsz; ++i)
17527 printf ("%02x ", pnote->descdata[i] & 0xff);
17528 printf ("\n");
17529 }
17530 break;
17531 }
17532
17533 return TRUE;
17534 }
17535
17536 static const char *
17537 get_v850_elf_note_type (enum v850_notes n_type)
17538 {
17539 static char buff[64];
17540
17541 switch (n_type)
17542 {
17543 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
17544 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
17545 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
17546 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
17547 case V850_NOTE_CACHE_INFO: return _("Use of cache");
17548 case V850_NOTE_MMU_INFO: return _("Use of MMU");
17549 default:
17550 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
17551 return buff;
17552 }
17553 }
17554
17555 static bfd_boolean
17556 print_v850_note (Elf_Internal_Note * pnote)
17557 {
17558 unsigned int val;
17559
17560 if (pnote->descsz != 4)
17561 return FALSE;
17562
17563 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
17564
17565 if (val == 0)
17566 {
17567 printf (_("not set\n"));
17568 return TRUE;
17569 }
17570
17571 switch (pnote->type)
17572 {
17573 case V850_NOTE_ALIGNMENT:
17574 switch (val)
17575 {
17576 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
17577 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
17578 }
17579 break;
17580
17581 case V850_NOTE_DATA_SIZE:
17582 switch (val)
17583 {
17584 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
17585 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
17586 }
17587 break;
17588
17589 case V850_NOTE_FPU_INFO:
17590 switch (val)
17591 {
17592 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
17593 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
17594 }
17595 break;
17596
17597 case V850_NOTE_MMU_INFO:
17598 case V850_NOTE_CACHE_INFO:
17599 case V850_NOTE_SIMD_INFO:
17600 if (val == EF_RH850_SIMD)
17601 {
17602 printf (_("yes\n"));
17603 return TRUE;
17604 }
17605 break;
17606
17607 default:
17608 /* An 'unknown note type' message will already have been displayed. */
17609 break;
17610 }
17611
17612 printf (_("unknown value: %x\n"), val);
17613 return FALSE;
17614 }
17615
17616 static bfd_boolean
17617 process_netbsd_elf_note (Elf_Internal_Note * pnote)
17618 {
17619 unsigned int version;
17620
17621 switch (pnote->type)
17622 {
17623 case NT_NETBSD_IDENT:
17624 version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
17625 if ((version / 10000) % 100)
17626 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
17627 version, version / 100000000, (version / 1000000) % 100,
17628 (version / 10000) % 100 > 26 ? "Z" : "",
17629 'A' + (version / 10000) % 26);
17630 else
17631 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
17632 version, version / 100000000, (version / 1000000) % 100,
17633 (version / 100) % 100);
17634 return TRUE;
17635
17636 case NT_NETBSD_MARCH:
17637 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
17638 pnote->descdata);
17639 return TRUE;
17640
17641 default:
17642 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
17643 pnote->type);
17644 return FALSE;
17645 }
17646 }
17647
17648 static const char *
17649 get_freebsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17650 {
17651 switch (e_type)
17652 {
17653 case NT_FREEBSD_THRMISC:
17654 return _("NT_THRMISC (thrmisc structure)");
17655 case NT_FREEBSD_PROCSTAT_PROC:
17656 return _("NT_PROCSTAT_PROC (proc data)");
17657 case NT_FREEBSD_PROCSTAT_FILES:
17658 return _("NT_PROCSTAT_FILES (files data)");
17659 case NT_FREEBSD_PROCSTAT_VMMAP:
17660 return _("NT_PROCSTAT_VMMAP (vmmap data)");
17661 case NT_FREEBSD_PROCSTAT_GROUPS:
17662 return _("NT_PROCSTAT_GROUPS (groups data)");
17663 case NT_FREEBSD_PROCSTAT_UMASK:
17664 return _("NT_PROCSTAT_UMASK (umask data)");
17665 case NT_FREEBSD_PROCSTAT_RLIMIT:
17666 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
17667 case NT_FREEBSD_PROCSTAT_OSREL:
17668 return _("NT_PROCSTAT_OSREL (osreldate data)");
17669 case NT_FREEBSD_PROCSTAT_PSSTRINGS:
17670 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
17671 case NT_FREEBSD_PROCSTAT_AUXV:
17672 return _("NT_PROCSTAT_AUXV (auxv data)");
17673 case NT_FREEBSD_PTLWPINFO:
17674 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
17675 }
17676 return get_note_type (filedata, e_type);
17677 }
17678
17679 static const char *
17680 get_netbsd_elfcore_note_type (Filedata * filedata, unsigned e_type)
17681 {
17682 static char buff[64];
17683
17684 if (e_type == NT_NETBSDCORE_PROCINFO)
17685 return _("NetBSD procinfo structure");
17686
17687 /* As of Jan 2002 there are no other machine-independent notes
17688 defined for NetBSD core files. If the note type is less
17689 than the start of the machine-dependent note types, we don't
17690 understand it. */
17691
17692 if (e_type < NT_NETBSDCORE_FIRSTMACH)
17693 {
17694 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17695 return buff;
17696 }
17697
17698 switch (filedata->file_header.e_machine)
17699 {
17700 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
17701 and PT_GETFPREGS == mach+2. */
17702
17703 case EM_OLD_ALPHA:
17704 case EM_ALPHA:
17705 case EM_SPARC:
17706 case EM_SPARC32PLUS:
17707 case EM_SPARCV9:
17708 switch (e_type)
17709 {
17710 case NT_NETBSDCORE_FIRSTMACH + 0:
17711 return _("PT_GETREGS (reg structure)");
17712 case NT_NETBSDCORE_FIRSTMACH + 2:
17713 return _("PT_GETFPREGS (fpreg structure)");
17714 default:
17715 break;
17716 }
17717 break;
17718
17719 /* On all other arch's, PT_GETREGS == mach+1 and
17720 PT_GETFPREGS == mach+3. */
17721 default:
17722 switch (e_type)
17723 {
17724 case NT_NETBSDCORE_FIRSTMACH + 1:
17725 return _("PT_GETREGS (reg structure)");
17726 case NT_NETBSDCORE_FIRSTMACH + 3:
17727 return _("PT_GETFPREGS (fpreg structure)");
17728 default:
17729 break;
17730 }
17731 }
17732
17733 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
17734 e_type - NT_NETBSDCORE_FIRSTMACH);
17735 return buff;
17736 }
17737
17738 static const char *
17739 get_stapsdt_note_type (unsigned e_type)
17740 {
17741 static char buff[64];
17742
17743 switch (e_type)
17744 {
17745 case NT_STAPSDT:
17746 return _("NT_STAPSDT (SystemTap probe descriptors)");
17747
17748 default:
17749 break;
17750 }
17751
17752 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17753 return buff;
17754 }
17755
17756 static bfd_boolean
17757 print_stapsdt_note (Elf_Internal_Note *pnote)
17758 {
17759 int addr_size = is_32bit_elf ? 4 : 8;
17760 char *data = pnote->descdata;
17761 char *data_end = pnote->descdata + pnote->descsz;
17762 bfd_vma pc, base_addr, semaphore;
17763 char *provider, *probe, *arg_fmt;
17764
17765 pc = byte_get ((unsigned char *) data, addr_size);
17766 data += addr_size;
17767 base_addr = byte_get ((unsigned char *) data, addr_size);
17768 data += addr_size;
17769 semaphore = byte_get ((unsigned char *) data, addr_size);
17770 data += addr_size;
17771
17772 provider = data;
17773 data += strlen (data) + 1;
17774 probe = data;
17775 data += strlen (data) + 1;
17776 arg_fmt = data;
17777 data += strlen (data) + 1;
17778
17779 printf (_(" Provider: %s\n"), provider);
17780 printf (_(" Name: %s\n"), probe);
17781 printf (_(" Location: "));
17782 print_vma (pc, FULL_HEX);
17783 printf (_(", Base: "));
17784 print_vma (base_addr, FULL_HEX);
17785 printf (_(", Semaphore: "));
17786 print_vma (semaphore, FULL_HEX);
17787 printf ("\n");
17788 printf (_(" Arguments: %s\n"), arg_fmt);
17789
17790 return data == data_end;
17791 }
17792
17793 static const char *
17794 get_ia64_vms_note_type (unsigned e_type)
17795 {
17796 static char buff[64];
17797
17798 switch (e_type)
17799 {
17800 case NT_VMS_MHD:
17801 return _("NT_VMS_MHD (module header)");
17802 case NT_VMS_LNM:
17803 return _("NT_VMS_LNM (language name)");
17804 case NT_VMS_SRC:
17805 return _("NT_VMS_SRC (source files)");
17806 case NT_VMS_TITLE:
17807 return "NT_VMS_TITLE";
17808 case NT_VMS_EIDC:
17809 return _("NT_VMS_EIDC (consistency check)");
17810 case NT_VMS_FPMODE:
17811 return _("NT_VMS_FPMODE (FP mode)");
17812 case NT_VMS_LINKTIME:
17813 return "NT_VMS_LINKTIME";
17814 case NT_VMS_IMGNAM:
17815 return _("NT_VMS_IMGNAM (image name)");
17816 case NT_VMS_IMGID:
17817 return _("NT_VMS_IMGID (image id)");
17818 case NT_VMS_LINKID:
17819 return _("NT_VMS_LINKID (link id)");
17820 case NT_VMS_IMGBID:
17821 return _("NT_VMS_IMGBID (build id)");
17822 case NT_VMS_GSTNAM:
17823 return _("NT_VMS_GSTNAM (sym table name)");
17824 case NT_VMS_ORIG_DYN:
17825 return "NT_VMS_ORIG_DYN";
17826 case NT_VMS_PATCHTIME:
17827 return "NT_VMS_PATCHTIME";
17828 default:
17829 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
17830 return buff;
17831 }
17832 }
17833
17834 static bfd_boolean
17835 print_ia64_vms_note (Elf_Internal_Note * pnote)
17836 {
17837 switch (pnote->type)
17838 {
17839 case NT_VMS_MHD:
17840 if (pnote->descsz > 36)
17841 {
17842 size_t l = strlen (pnote->descdata + 34);
17843 printf (_(" Creation date : %.17s\n"), pnote->descdata);
17844 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
17845 printf (_(" Module name : %s\n"), pnote->descdata + 34);
17846 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
17847 }
17848 else
17849 printf (_(" Invalid size\n"));
17850 break;
17851 case NT_VMS_LNM:
17852 printf (_(" Language: %s\n"), pnote->descdata);
17853 break;
17854 #ifdef BFD64
17855 case NT_VMS_FPMODE:
17856 printf (_(" Floating Point mode: "));
17857 printf ("0x%016" BFD_VMA_FMT "x\n",
17858 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
17859 break;
17860 case NT_VMS_LINKTIME:
17861 printf (_(" Link time: "));
17862 print_vms_time
17863 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17864 printf ("\n");
17865 break;
17866 case NT_VMS_PATCHTIME:
17867 printf (_(" Patch time: "));
17868 print_vms_time
17869 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
17870 printf ("\n");
17871 break;
17872 case NT_VMS_ORIG_DYN:
17873 printf (_(" Major id: %u, minor id: %u\n"),
17874 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
17875 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
17876 printf (_(" Last modified : "));
17877 print_vms_time
17878 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
17879 printf (_("\n Link flags : "));
17880 printf ("0x%016" BFD_VMA_FMT "x\n",
17881 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
17882 printf (_(" Header flags: 0x%08x\n"),
17883 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
17884 printf (_(" Image id : %s\n"), pnote->descdata + 32);
17885 break;
17886 #endif
17887 case NT_VMS_IMGNAM:
17888 printf (_(" Image name: %s\n"), pnote->descdata);
17889 break;
17890 case NT_VMS_GSTNAM:
17891 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
17892 break;
17893 case NT_VMS_IMGID:
17894 printf (_(" Image id: %s\n"), pnote->descdata);
17895 break;
17896 case NT_VMS_LINKID:
17897 printf (_(" Linker id: %s\n"), pnote->descdata);
17898 break;
17899 default:
17900 return FALSE;
17901 }
17902 return TRUE;
17903 }
17904
17905 /* Find the symbol associated with a build attribute that is attached
17906 to address OFFSET. If PNAME is non-NULL then store the name of
17907 the symbol (if found) in the provided pointer, Returns NULL if a
17908 symbol could not be found. */
17909
17910 static Elf_Internal_Sym *
17911 get_symbol_for_build_attribute (Filedata * filedata,
17912 unsigned long offset,
17913 bfd_boolean is_open_attr,
17914 const char ** pname)
17915 {
17916 static Filedata * saved_filedata = NULL;
17917 static char * strtab;
17918 static unsigned long strtablen;
17919 static Elf_Internal_Sym * symtab;
17920 static unsigned long nsyms;
17921 Elf_Internal_Sym * saved_sym = NULL;
17922 Elf_Internal_Sym * sym;
17923
17924 if (filedata->section_headers != NULL
17925 && (saved_filedata == NULL || filedata != saved_filedata))
17926 {
17927 Elf_Internal_Shdr * symsec;
17928
17929 /* Load the symbol and string sections. */
17930 for (symsec = filedata->section_headers;
17931 symsec < filedata->section_headers + filedata->file_header.e_shnum;
17932 symsec ++)
17933 {
17934 if (symsec->sh_type == SHT_SYMTAB)
17935 {
17936 symtab = GET_ELF_SYMBOLS (filedata, symsec, & nsyms);
17937
17938 if (symsec->sh_link < filedata->file_header.e_shnum)
17939 {
17940 Elf_Internal_Shdr * strtab_sec = filedata->section_headers + symsec->sh_link;
17941
17942 strtab = (char *) get_data (NULL, filedata, strtab_sec->sh_offset,
17943 1, strtab_sec->sh_size,
17944 _("string table"));
17945 strtablen = strtab != NULL ? strtab_sec->sh_size : 0;
17946 }
17947 }
17948 }
17949 saved_filedata = filedata;
17950 }
17951
17952 if (symtab == NULL || strtab == NULL)
17953 return NULL;
17954
17955 /* Find a symbol whose value matches offset. */
17956 for (sym = symtab; sym < symtab + nsyms; sym ++)
17957 if (sym->st_value == offset)
17958 {
17959 if (sym->st_name >= strtablen)
17960 /* Huh ? This should not happen. */
17961 continue;
17962
17963 if (strtab[sym->st_name] == 0)
17964 continue;
17965
17966 /* The AArch64 and ARM architectures define mapping symbols
17967 (eg $d, $x, $t) which we want to ignore. */
17968 if (strtab[sym->st_name] == '$'
17969 && strtab[sym->st_name + 1] != 0
17970 && strtab[sym->st_name + 2] == 0)
17971 continue;
17972
17973 if (is_open_attr)
17974 {
17975 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17976 and FILE or OBJECT symbols over NOTYPE symbols. We skip
17977 FUNC symbols entirely. */
17978 switch (ELF_ST_TYPE (sym->st_info))
17979 {
17980 case STT_OBJECT:
17981 case STT_FILE:
17982 saved_sym = sym;
17983 if (sym->st_size)
17984 {
17985 /* If the symbol has a size associated
17986 with it then we can stop searching. */
17987 sym = symtab + nsyms;
17988 }
17989 continue;
17990
17991 case STT_FUNC:
17992 /* Ignore function symbols. */
17993 continue;
17994
17995 default:
17996 break;
17997 }
17998
17999 switch (ELF_ST_BIND (sym->st_info))
18000 {
18001 case STB_GLOBAL:
18002 if (saved_sym == NULL
18003 || ELF_ST_TYPE (saved_sym->st_info) != STT_OBJECT)
18004 saved_sym = sym;
18005 break;
18006
18007 case STB_LOCAL:
18008 if (saved_sym == NULL)
18009 saved_sym = sym;
18010 break;
18011
18012 default:
18013 break;
18014 }
18015 }
18016 else
18017 {
18018 if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
18019 continue;
18020
18021 saved_sym = sym;
18022 break;
18023 }
18024 }
18025
18026 if (saved_sym && pname)
18027 * pname = strtab + saved_sym->st_name;
18028
18029 return saved_sym;
18030 }
18031
18032 /* Returns true iff addr1 and addr2 are in the same section. */
18033
18034 static bfd_boolean
18035 same_section (Filedata * filedata, unsigned long addr1, unsigned long addr2)
18036 {
18037 Elf_Internal_Shdr * a1;
18038 Elf_Internal_Shdr * a2;
18039
18040 a1 = find_section_by_address (filedata, addr1);
18041 a2 = find_section_by_address (filedata, addr2);
18042
18043 return a1 == a2 && a1 != NULL;
18044 }
18045
18046 static bfd_boolean
18047 print_gnu_build_attribute_description (Elf_Internal_Note * pnote,
18048 Filedata * filedata)
18049 {
18050 static unsigned long global_offset = 0;
18051 static unsigned long global_end = 0;
18052 static unsigned long func_offset = 0;
18053 static unsigned long func_end = 0;
18054
18055 Elf_Internal_Sym * sym;
18056 const char * name;
18057 unsigned long start;
18058 unsigned long end;
18059 bfd_boolean is_open_attr = pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN;
18060
18061 switch (pnote->descsz)
18062 {
18063 case 0:
18064 /* A zero-length description means that the range of
18065 the previous note of the same type should be used. */
18066 if (is_open_attr)
18067 {
18068 if (global_end > global_offset)
18069 printf (_(" Applies to region from %#lx to %#lx\n"),
18070 global_offset, global_end);
18071 else
18072 printf (_(" Applies to region from %#lx\n"), global_offset);
18073 }
18074 else
18075 {
18076 if (func_end > func_offset)
18077 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset, func_end);
18078 else
18079 printf (_(" Applies to region from %#lx\n"), func_offset);
18080 }
18081 return TRUE;
18082
18083 case 4:
18084 start = byte_get ((unsigned char *) pnote->descdata, 4);
18085 end = 0;
18086 break;
18087
18088 case 8:
18089 if (is_32bit_elf)
18090 {
18091 /* FIXME: We should check that version 3+ notes are being used here... */
18092 start = byte_get ((unsigned char *) pnote->descdata, 4);
18093 end = byte_get ((unsigned char *) pnote->descdata + 4, 4);
18094 }
18095 else
18096 {
18097 start = byte_get ((unsigned char *) pnote->descdata, 8);
18098 end = 0;
18099 }
18100 break;
18101
18102 case 16:
18103 start = byte_get ((unsigned char *) pnote->descdata, 8);
18104 end = byte_get ((unsigned char *) pnote->descdata + 8, 8);
18105 break;
18106
18107 default:
18108 error (_(" <invalid description size: %lx>\n"), pnote->descsz);
18109 printf (_(" <invalid descsz>"));
18110 return FALSE;
18111 }
18112
18113 name = NULL;
18114 sym = get_symbol_for_build_attribute (filedata, start, is_open_attr, & name);
18115 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
18116 in order to avoid them being confused with the start address of the
18117 first function in the file... */
18118 if (sym == NULL && is_open_attr)
18119 sym = get_symbol_for_build_attribute (filedata, start + 2, is_open_attr,
18120 & name);
18121
18122 if (end == 0 && sym != NULL && sym->st_size > 0)
18123 end = start + sym->st_size;
18124
18125 if (is_open_attr)
18126 {
18127 /* FIXME: Need to properly allow for section alignment.
18128 16 is just the alignment used on x86_64. */
18129 if (global_end > 0
18130 && start > BFD_ALIGN (global_end, 16)
18131 /* Build notes are not guaranteed to be organised in order of
18132 increasing address, but we should find the all of the notes
18133 for one section in the same place. */
18134 && same_section (filedata, start, global_end))
18135 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
18136 global_end + 1, start - 1);
18137
18138 printf (_(" Applies to region from %#lx"), start);
18139 global_offset = start;
18140
18141 if (end)
18142 {
18143 printf (_(" to %#lx"), end);
18144 global_end = end;
18145 }
18146 }
18147 else
18148 {
18149 printf (_(" Applies to region from %#lx"), start);
18150 func_offset = start;
18151
18152 if (end)
18153 {
18154 printf (_(" to %#lx"), end);
18155 func_end = end;
18156 }
18157 }
18158
18159 if (sym && name)
18160 printf (_(" (%s)"), name);
18161
18162 printf ("\n");
18163 return TRUE;
18164 }
18165
18166 static bfd_boolean
18167 print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
18168 {
18169 static const char string_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING, 0 };
18170 static const char number_expected [2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC, 0 };
18171 static const char bool_expected [3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE, 0 };
18172 char name_type;
18173 char name_attribute;
18174 const char * expected_types;
18175 const char * name = pnote->namedata;
18176 const char * text;
18177 signed int left;
18178
18179 if (name == NULL || pnote->namesz < 2)
18180 {
18181 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
18182 print_symbol (-20, _(" <corrupt name>"));
18183 return FALSE;
18184 }
18185
18186 if (do_wide)
18187 left = 28;
18188 else
18189 left = 20;
18190
18191 /* Version 2 of the spec adds a "GA" prefix to the name field. */
18192 if (name[0] == 'G' && name[1] == 'A')
18193 {
18194 if (pnote->namesz < 4)
18195 {
18196 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
18197 print_symbol (-20, _(" <corrupt name>"));
18198 return FALSE;
18199 }
18200
18201 printf ("GA");
18202 name += 2;
18203 left -= 2;
18204 }
18205
18206 switch ((name_type = * name))
18207 {
18208 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
18209 case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
18210 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
18211 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
18212 printf ("%c", * name);
18213 left --;
18214 break;
18215 default:
18216 error (_("unrecognised attribute type in name field: %d\n"), name_type);
18217 print_symbol (-20, _("<unknown name type>"));
18218 return FALSE;
18219 }
18220
18221 ++ name;
18222 text = NULL;
18223
18224 switch ((name_attribute = * name))
18225 {
18226 case GNU_BUILD_ATTRIBUTE_VERSION:
18227 text = _("<version>");
18228 expected_types = string_expected;
18229 ++ name;
18230 break;
18231 case GNU_BUILD_ATTRIBUTE_STACK_PROT:
18232 text = _("<stack prot>");
18233 expected_types = "!+*";
18234 ++ name;
18235 break;
18236 case GNU_BUILD_ATTRIBUTE_RELRO:
18237 text = _("<relro>");
18238 expected_types = bool_expected;
18239 ++ name;
18240 break;
18241 case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
18242 text = _("<stack size>");
18243 expected_types = number_expected;
18244 ++ name;
18245 break;
18246 case GNU_BUILD_ATTRIBUTE_TOOL:
18247 text = _("<tool>");
18248 expected_types = string_expected;
18249 ++ name;
18250 break;
18251 case GNU_BUILD_ATTRIBUTE_ABI:
18252 text = _("<ABI>");
18253 expected_types = "$*";
18254 ++ name;
18255 break;
18256 case GNU_BUILD_ATTRIBUTE_PIC:
18257 text = _("<PIC>");
18258 expected_types = number_expected;
18259 ++ name;
18260 break;
18261 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM:
18262 text = _("<short enum>");
18263 expected_types = bool_expected;
18264 ++ name;
18265 break;
18266 default:
18267 if (ISPRINT (* name))
18268 {
18269 int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
18270
18271 if (len > left && ! do_wide)
18272 len = left;
18273 printf ("%.*s:", len, name);
18274 left -= len;
18275 name += len;
18276 }
18277 else
18278 {
18279 static char tmpbuf [128];
18280
18281 error (_("unrecognised byte in name field: %d\n"), * name);
18282 sprintf (tmpbuf, _("<unknown:_%d>"), * name);
18283 text = tmpbuf;
18284 name ++;
18285 }
18286 expected_types = "*$!+";
18287 break;
18288 }
18289
18290 if (text)
18291 left -= printf ("%s", text);
18292
18293 if (strchr (expected_types, name_type) == NULL)
18294 warn (_("attribute does not have an expected type (%c)\n"), name_type);
18295
18296 if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
18297 {
18298 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
18299 (unsigned long) pnote->namesz,
18300 (long) (name - pnote->namedata));
18301 return FALSE;
18302 }
18303
18304 if (left < 1 && ! do_wide)
18305 return TRUE;
18306
18307 switch (name_type)
18308 {
18309 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
18310 {
18311 unsigned int bytes;
18312 unsigned long long val = 0;
18313 unsigned int shift = 0;
18314 char * decoded = NULL;
18315
18316 bytes = pnote->namesz - (name - pnote->namedata);
18317 if (bytes > 0)
18318 /* The -1 is because the name field is always 0 terminated, and we
18319 want to be able to ensure that the shift in the while loop below
18320 will not overflow. */
18321 -- bytes;
18322
18323 if (bytes > sizeof (val))
18324 {
18325 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
18326 bytes);
18327 bytes = sizeof (val);
18328 }
18329 /* We do not bother to warn if bytes == 0 as this can
18330 happen with some early versions of the gcc plugin. */
18331
18332 while (bytes --)
18333 {
18334 unsigned long byte = (* name ++) & 0xff;
18335
18336 val |= byte << shift;
18337 shift += 8;
18338 }
18339
18340 switch (name_attribute)
18341 {
18342 case GNU_BUILD_ATTRIBUTE_PIC:
18343 switch (val)
18344 {
18345 case 0: decoded = "static"; break;
18346 case 1: decoded = "pic"; break;
18347 case 2: decoded = "PIC"; break;
18348 case 3: decoded = "pie"; break;
18349 case 4: decoded = "PIE"; break;
18350 default: break;
18351 }
18352 break;
18353 case GNU_BUILD_ATTRIBUTE_STACK_PROT:
18354 switch (val)
18355 {
18356 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
18357 case 0: decoded = "off"; break;
18358 case 1: decoded = "on"; break;
18359 case 2: decoded = "all"; break;
18360 case 3: decoded = "strong"; break;
18361 case 4: decoded = "explicit"; break;
18362 default: break;
18363 }
18364 break;
18365 default:
18366 break;
18367 }
18368
18369 if (decoded != NULL)
18370 {
18371 print_symbol (-left, decoded);
18372 left = 0;
18373 }
18374 else if (val == 0)
18375 {
18376 printf ("0x0");
18377 left -= 3;
18378 }
18379 else
18380 {
18381 if (do_wide)
18382 left -= printf ("0x%llx", val);
18383 else
18384 left -= printf ("0x%-.*llx", left, val);
18385 }
18386 }
18387 break;
18388 case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
18389 left -= print_symbol (- left, name);
18390 break;
18391 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
18392 left -= print_symbol (- left, "true");
18393 break;
18394 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
18395 left -= print_symbol (- left, "false");
18396 break;
18397 }
18398
18399 if (do_wide && left > 0)
18400 printf ("%-*s", left, " ");
18401
18402 return TRUE;
18403 }
18404
18405 /* Note that by the ELF standard, the name field is already null byte
18406 terminated, and namesz includes the terminating null byte.
18407 I.E. the value of namesz for the name "FSF" is 4.
18408
18409 If the value of namesz is zero, there is no name present. */
18410
18411 static bfd_boolean
18412 process_note (Elf_Internal_Note * pnote,
18413 Filedata * filedata)
18414 {
18415 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
18416 const char * nt;
18417
18418 if (pnote->namesz == 0)
18419 /* If there is no note name, then use the default set of
18420 note type strings. */
18421 nt = get_note_type (filedata, pnote->type);
18422
18423 else if (const_strneq (pnote->namedata, "GNU"))
18424 /* GNU-specific object file notes. */
18425 nt = get_gnu_elf_note_type (pnote->type);
18426
18427 else if (const_strneq (pnote->namedata, "FreeBSD"))
18428 /* FreeBSD-specific core file notes. */
18429 nt = get_freebsd_elfcore_note_type (filedata, pnote->type);
18430
18431 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
18432 /* NetBSD-specific core file notes. */
18433 nt = get_netbsd_elfcore_note_type (filedata, pnote->type);
18434
18435 else if (const_strneq (pnote->namedata, "NetBSD"))
18436 /* NetBSD-specific core file notes. */
18437 return process_netbsd_elf_note (pnote);
18438
18439 else if (strneq (pnote->namedata, "SPU/", 4))
18440 {
18441 /* SPU-specific core file notes. */
18442 nt = pnote->namedata + 4;
18443 name = "SPU";
18444 }
18445
18446 else if (const_strneq (pnote->namedata, "IPF/VMS"))
18447 /* VMS/ia64-specific file notes. */
18448 nt = get_ia64_vms_note_type (pnote->type);
18449
18450 else if (const_strneq (pnote->namedata, "stapsdt"))
18451 nt = get_stapsdt_note_type (pnote->type);
18452
18453 else
18454 /* Don't recognize this note name; just use the default set of
18455 note type strings. */
18456 nt = get_note_type (filedata, pnote->type);
18457
18458 printf (" ");
18459
18460 if (((const_strneq (pnote->namedata, "GA")
18461 && strchr ("*$!+", pnote->namedata[2]) != NULL)
18462 || strchr ("*$!+", pnote->namedata[0]) != NULL)
18463 && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
18464 || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
18465 print_gnu_build_attribute_name (pnote);
18466 else
18467 print_symbol (-20, name);
18468
18469 if (do_wide)
18470 printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
18471 else
18472 printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
18473
18474 if (const_strneq (pnote->namedata, "IPF/VMS"))
18475 return print_ia64_vms_note (pnote);
18476 else if (const_strneq (pnote->namedata, "GNU"))
18477 return print_gnu_note (filedata, pnote);
18478 else if (const_strneq (pnote->namedata, "stapsdt"))
18479 return print_stapsdt_note (pnote);
18480 else if (const_strneq (pnote->namedata, "CORE"))
18481 return print_core_note (pnote);
18482 else if (((const_strneq (pnote->namedata, "GA")
18483 && strchr ("*$!+", pnote->namedata[2]) != NULL)
18484 || strchr ("*$!+", pnote->namedata[0]) != NULL)
18485 && (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
18486 || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC))
18487 return print_gnu_build_attribute_description (pnote, filedata);
18488
18489 if (pnote->descsz)
18490 {
18491 unsigned long i;
18492
18493 printf (_(" description data: "));
18494 for (i = 0; i < pnote->descsz; i++)
18495 printf ("%02x ", pnote->descdata[i]);
18496 if (!do_wide)
18497 printf ("\n");
18498 }
18499
18500 if (do_wide)
18501 printf ("\n");
18502
18503 return TRUE;
18504 }
18505
18506 static bfd_boolean
18507 process_notes_at (Filedata * filedata,
18508 Elf_Internal_Shdr * section,
18509 bfd_vma offset,
18510 bfd_vma length,
18511 bfd_vma align)
18512 {
18513 Elf_External_Note * pnotes;
18514 Elf_External_Note * external;
18515 char * end;
18516 bfd_boolean res = TRUE;
18517
18518 if (length <= 0)
18519 return FALSE;
18520
18521 if (section)
18522 {
18523 pnotes = (Elf_External_Note *) get_section_contents (section, filedata);
18524 if (pnotes)
18525 {
18526 if (! apply_relocations (filedata, section, (unsigned char *) pnotes, length, NULL, NULL))
18527 return FALSE;
18528 }
18529 }
18530 else
18531 pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18532 _("notes"));
18533
18534 if (pnotes == NULL)
18535 return FALSE;
18536
18537 external = pnotes;
18538
18539 if (section)
18540 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata, section));
18541 else
18542 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
18543 (unsigned long) offset, (unsigned long) length);
18544
18545 /* NB: Some note sections may have alignment value of 0 or 1. gABI
18546 specifies that notes should be aligned to 4 bytes in 32-bit
18547 objects and to 8 bytes in 64-bit objects. As a Linux extension,
18548 we also support 4 byte alignment in 64-bit objects. If section
18549 alignment is less than 4, we treate alignment as 4 bytes. */
18550 if (align < 4)
18551 align = 4;
18552 else if (align != 4 && align != 8)
18553 {
18554 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
18555 (long) align);
18556 return FALSE;
18557 }
18558
18559 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
18560
18561 end = (char *) pnotes + length;
18562 while ((char *) external < end)
18563 {
18564 Elf_Internal_Note inote;
18565 size_t min_notesz;
18566 char * next;
18567 char * temp = NULL;
18568 size_t data_remaining = end - (char *) external;
18569
18570 if (!is_ia64_vms (filedata))
18571 {
18572 /* PR binutils/15191
18573 Make sure that there is enough data to read. */
18574 min_notesz = offsetof (Elf_External_Note, name);
18575 if (data_remaining < min_notesz)
18576 {
18577 warn (ngettext ("Corrupt note: only %ld byte remains, "
18578 "not enough for a full note\n",
18579 "Corrupt note: only %ld bytes remain, "
18580 "not enough for a full note\n",
18581 data_remaining),
18582 (long) data_remaining);
18583 break;
18584 }
18585 data_remaining -= min_notesz;
18586
18587 inote.type = BYTE_GET (external->type);
18588 inote.namesz = BYTE_GET (external->namesz);
18589 inote.namedata = external->name;
18590 inote.descsz = BYTE_GET (external->descsz);
18591 inote.descdata = ((char *) external
18592 + ELF_NOTE_DESC_OFFSET (inote.namesz, align));
18593 inote.descpos = offset + (inote.descdata - (char *) pnotes);
18594 next = ((char *) external
18595 + ELF_NOTE_NEXT_OFFSET (inote.namesz, inote.descsz, align));
18596 }
18597 else
18598 {
18599 Elf64_External_VMS_Note *vms_external;
18600
18601 /* PR binutils/15191
18602 Make sure that there is enough data to read. */
18603 min_notesz = offsetof (Elf64_External_VMS_Note, name);
18604 if (data_remaining < min_notesz)
18605 {
18606 warn (ngettext ("Corrupt note: only %ld byte remains, "
18607 "not enough for a full note\n",
18608 "Corrupt note: only %ld bytes remain, "
18609 "not enough for a full note\n",
18610 data_remaining),
18611 (long) data_remaining);
18612 break;
18613 }
18614 data_remaining -= min_notesz;
18615
18616 vms_external = (Elf64_External_VMS_Note *) external;
18617 inote.type = BYTE_GET (vms_external->type);
18618 inote.namesz = BYTE_GET (vms_external->namesz);
18619 inote.namedata = vms_external->name;
18620 inote.descsz = BYTE_GET (vms_external->descsz);
18621 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
18622 inote.descpos = offset + (inote.descdata - (char *) pnotes);
18623 next = inote.descdata + align_power (inote.descsz, 3);
18624 }
18625
18626 /* PR 17531: file: 3443835e. */
18627 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
18628 if ((size_t) (inote.descdata - inote.namedata) < inote.namesz
18629 || (size_t) (inote.descdata - inote.namedata) > data_remaining
18630 || (size_t) (next - inote.descdata) < inote.descsz
18631 || ((size_t) (next - inote.descdata)
18632 > data_remaining - (size_t) (inote.descdata - inote.namedata)))
18633 {
18634 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
18635 (unsigned long) ((char *) external - (char *) pnotes));
18636 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
18637 inote.type, inote.namesz, inote.descsz, (int) align);
18638 break;
18639 }
18640
18641 external = (Elf_External_Note *) next;
18642
18643 /* Verify that name is null terminated. It appears that at least
18644 one version of Linux (RedHat 6.0) generates corefiles that don't
18645 comply with the ELF spec by failing to include the null byte in
18646 namesz. */
18647 if (inote.namedata[inote.namesz - 1] != '\0')
18648 {
18649 if ((size_t) (inote.descdata - inote.namedata) == inote.namesz)
18650 {
18651 temp = (char *) malloc (inote.namesz + 1);
18652 if (temp == NULL)
18653 {
18654 error (_("Out of memory allocating space for inote name\n"));
18655 res = FALSE;
18656 break;
18657 }
18658
18659 memcpy (temp, inote.namedata, inote.namesz);
18660 inote.namedata = temp;
18661 }
18662 inote.namedata[inote.namesz] = 0;
18663 }
18664
18665 if (! process_note (& inote, filedata))
18666 res = FALSE;
18667
18668 if (temp != NULL)
18669 {
18670 free (temp);
18671 temp = NULL;
18672 }
18673 }
18674
18675 free (pnotes);
18676
18677 return res;
18678 }
18679
18680 static bfd_boolean
18681 process_corefile_note_segments (Filedata * filedata)
18682 {
18683 Elf_Internal_Phdr * segment;
18684 unsigned int i;
18685 bfd_boolean res = TRUE;
18686
18687 if (! get_program_headers (filedata))
18688 return TRUE;
18689
18690 for (i = 0, segment = filedata->program_headers;
18691 i < filedata->file_header.e_phnum;
18692 i++, segment++)
18693 {
18694 if (segment->p_type == PT_NOTE)
18695 if (! process_notes_at (filedata, NULL,
18696 (bfd_vma) segment->p_offset,
18697 (bfd_vma) segment->p_filesz,
18698 (bfd_vma) segment->p_align))
18699 res = FALSE;
18700 }
18701
18702 return res;
18703 }
18704
18705 static bfd_boolean
18706 process_v850_notes (Filedata * filedata, bfd_vma offset, bfd_vma length)
18707 {
18708 Elf_External_Note * pnotes;
18709 Elf_External_Note * external;
18710 char * end;
18711 bfd_boolean res = TRUE;
18712
18713 if (length <= 0)
18714 return FALSE;
18715
18716 pnotes = (Elf_External_Note *) get_data (NULL, filedata, offset, 1, length,
18717 _("v850 notes"));
18718 if (pnotes == NULL)
18719 return FALSE;
18720
18721 external = pnotes;
18722 end = (char*) pnotes + length;
18723
18724 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
18725 (unsigned long) offset, (unsigned long) length);
18726
18727 while ((char *) external + sizeof (Elf_External_Note) < end)
18728 {
18729 Elf_External_Note * next;
18730 Elf_Internal_Note inote;
18731
18732 inote.type = BYTE_GET (external->type);
18733 inote.namesz = BYTE_GET (external->namesz);
18734 inote.namedata = external->name;
18735 inote.descsz = BYTE_GET (external->descsz);
18736 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
18737 inote.descpos = offset + (inote.descdata - (char *) pnotes);
18738
18739 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
18740 {
18741 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
18742 inote.descdata = inote.namedata;
18743 inote.namesz = 0;
18744 }
18745
18746 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
18747
18748 if ( ((char *) next > end)
18749 || ((char *) next < (char *) pnotes))
18750 {
18751 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
18752 (unsigned long) ((char *) external - (char *) pnotes));
18753 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18754 inote.type, inote.namesz, inote.descsz);
18755 break;
18756 }
18757
18758 external = next;
18759
18760 /* Prevent out-of-bounds indexing. */
18761 if ( inote.namedata + inote.namesz > end
18762 || inote.namedata + inote.namesz < inote.namedata)
18763 {
18764 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
18765 (unsigned long) ((char *) external - (char *) pnotes));
18766 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18767 inote.type, inote.namesz, inote.descsz);
18768 break;
18769 }
18770
18771 printf (" %s: ", get_v850_elf_note_type (inote.type));
18772
18773 if (! print_v850_note (& inote))
18774 {
18775 res = FALSE;
18776 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
18777 inote.namesz, inote.descsz);
18778 }
18779 }
18780
18781 free (pnotes);
18782
18783 return res;
18784 }
18785
18786 static bfd_boolean
18787 process_note_sections (Filedata * filedata)
18788 {
18789 Elf_Internal_Shdr * section;
18790 unsigned long i;
18791 unsigned int n = 0;
18792 bfd_boolean res = TRUE;
18793
18794 for (i = 0, section = filedata->section_headers;
18795 i < filedata->file_header.e_shnum && section != NULL;
18796 i++, section++)
18797 {
18798 if (section->sh_type == SHT_NOTE)
18799 {
18800 if (! process_notes_at (filedata, section,
18801 (bfd_vma) section->sh_offset,
18802 (bfd_vma) section->sh_size,
18803 (bfd_vma) section->sh_addralign))
18804 res = FALSE;
18805 n++;
18806 }
18807
18808 if (( filedata->file_header.e_machine == EM_V800
18809 || filedata->file_header.e_machine == EM_V850
18810 || filedata->file_header.e_machine == EM_CYGNUS_V850)
18811 && section->sh_type == SHT_RENESAS_INFO)
18812 {
18813 if (! process_v850_notes (filedata,
18814 (bfd_vma) section->sh_offset,
18815 (bfd_vma) section->sh_size))
18816 res = FALSE;
18817 n++;
18818 }
18819 }
18820
18821 if (n == 0)
18822 /* Try processing NOTE segments instead. */
18823 return process_corefile_note_segments (filedata);
18824
18825 return res;
18826 }
18827
18828 static bfd_boolean
18829 process_notes (Filedata * filedata)
18830 {
18831 /* If we have not been asked to display the notes then do nothing. */
18832 if (! do_notes)
18833 return TRUE;
18834
18835 if (filedata->file_header.e_type != ET_CORE)
18836 return process_note_sections (filedata);
18837
18838 /* No program headers means no NOTE segment. */
18839 if (filedata->file_header.e_phnum > 0)
18840 return process_corefile_note_segments (filedata);
18841
18842 printf (_("No note segments present in the core file.\n"));
18843 return TRUE;
18844 }
18845
18846 static unsigned char *
18847 display_public_gnu_attributes (unsigned char * start,
18848 const unsigned char * const end)
18849 {
18850 printf (_(" Unknown GNU attribute: %s\n"), start);
18851
18852 start += strnlen ((char *) start, end - start);
18853 display_raw_attribute (start, end);
18854
18855 return (unsigned char *) end;
18856 }
18857
18858 static unsigned char *
18859 display_generic_attribute (unsigned char * start,
18860 unsigned int tag,
18861 const unsigned char * const end)
18862 {
18863 if (tag == 0)
18864 return (unsigned char *) end;
18865
18866 return display_tag_value (tag, start, end);
18867 }
18868
18869 static bfd_boolean
18870 process_arch_specific (Filedata * filedata)
18871 {
18872 if (! do_arch)
18873 return TRUE;
18874
18875 switch (filedata->file_header.e_machine)
18876 {
18877 case EM_ARC:
18878 case EM_ARC_COMPACT:
18879 case EM_ARC_COMPACT2:
18880 return process_attributes (filedata, "ARC", SHT_ARC_ATTRIBUTES,
18881 display_arc_attribute,
18882 display_generic_attribute);
18883 case EM_ARM:
18884 return process_attributes (filedata, "aeabi", SHT_ARM_ATTRIBUTES,
18885 display_arm_attribute,
18886 display_generic_attribute);
18887
18888 case EM_MIPS:
18889 case EM_MIPS_RS3_LE:
18890 return process_mips_specific (filedata);
18891
18892 case EM_MSP430:
18893 return process_attributes (filedata, "mspabi", SHT_MSP430_ATTRIBUTES,
18894 display_msp430x_attribute,
18895 display_generic_attribute);
18896
18897 case EM_NDS32:
18898 return process_nds32_specific (filedata);
18899
18900 case EM_PPC:
18901 case EM_PPC64:
18902 return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18903 display_power_gnu_attribute);
18904
18905 case EM_S390:
18906 case EM_S390_OLD:
18907 return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18908 display_s390_gnu_attribute);
18909
18910 case EM_SPARC:
18911 case EM_SPARC32PLUS:
18912 case EM_SPARCV9:
18913 return process_attributes (filedata, NULL, SHT_GNU_ATTRIBUTES, NULL,
18914 display_sparc_gnu_attribute);
18915
18916 case EM_TI_C6000:
18917 return process_attributes (filedata, "c6xabi", SHT_C6000_ATTRIBUTES,
18918 display_tic6x_attribute,
18919 display_generic_attribute);
18920
18921 default:
18922 return process_attributes (filedata, "gnu", SHT_GNU_ATTRIBUTES,
18923 display_public_gnu_attributes,
18924 display_generic_attribute);
18925 }
18926 }
18927
18928 static bfd_boolean
18929 get_file_header (Filedata * filedata)
18930 {
18931 /* Read in the identity array. */
18932 if (fread (filedata->file_header.e_ident, EI_NIDENT, 1, filedata->handle) != 1)
18933 return FALSE;
18934
18935 /* Determine how to read the rest of the header. */
18936 switch (filedata->file_header.e_ident[EI_DATA])
18937 {
18938 default:
18939 case ELFDATANONE:
18940 case ELFDATA2LSB:
18941 byte_get = byte_get_little_endian;
18942 byte_put = byte_put_little_endian;
18943 break;
18944 case ELFDATA2MSB:
18945 byte_get = byte_get_big_endian;
18946 byte_put = byte_put_big_endian;
18947 break;
18948 }
18949
18950 /* For now we only support 32 bit and 64 bit ELF files. */
18951 is_32bit_elf = (filedata->file_header.e_ident[EI_CLASS] != ELFCLASS64);
18952
18953 /* Read in the rest of the header. */
18954 if (is_32bit_elf)
18955 {
18956 Elf32_External_Ehdr ehdr32;
18957
18958 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, filedata->handle) != 1)
18959 return FALSE;
18960
18961 filedata->file_header.e_type = BYTE_GET (ehdr32.e_type);
18962 filedata->file_header.e_machine = BYTE_GET (ehdr32.e_machine);
18963 filedata->file_header.e_version = BYTE_GET (ehdr32.e_version);
18964 filedata->file_header.e_entry = BYTE_GET (ehdr32.e_entry);
18965 filedata->file_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
18966 filedata->file_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
18967 filedata->file_header.e_flags = BYTE_GET (ehdr32.e_flags);
18968 filedata->file_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
18969 filedata->file_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
18970 filedata->file_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
18971 filedata->file_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
18972 filedata->file_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
18973 filedata->file_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
18974 }
18975 else
18976 {
18977 Elf64_External_Ehdr ehdr64;
18978
18979 /* If we have been compiled with sizeof (bfd_vma) == 4, then
18980 we will not be able to cope with the 64bit data found in
18981 64 ELF files. Detect this now and abort before we start
18982 overwriting things. */
18983 if (sizeof (bfd_vma) < 8)
18984 {
18985 error (_("This instance of readelf has been built without support for a\n\
18986 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18987 return FALSE;
18988 }
18989
18990 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, filedata->handle) != 1)
18991 return FALSE;
18992
18993 filedata->file_header.e_type = BYTE_GET (ehdr64.e_type);
18994 filedata->file_header.e_machine = BYTE_GET (ehdr64.e_machine);
18995 filedata->file_header.e_version = BYTE_GET (ehdr64.e_version);
18996 filedata->file_header.e_entry = BYTE_GET (ehdr64.e_entry);
18997 filedata->file_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
18998 filedata->file_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
18999 filedata->file_header.e_flags = BYTE_GET (ehdr64.e_flags);
19000 filedata->file_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
19001 filedata->file_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
19002 filedata->file_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
19003 filedata->file_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
19004 filedata->file_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
19005 filedata->file_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
19006 }
19007
19008 if (filedata->file_header.e_shoff)
19009 {
19010 /* There may be some extensions in the first section header. Don't
19011 bomb if we can't read it. */
19012 if (is_32bit_elf)
19013 get_32bit_section_headers (filedata, TRUE);
19014 else
19015 get_64bit_section_headers (filedata, TRUE);
19016 }
19017
19018 return TRUE;
19019 }
19020
19021 static void
19022 close_file (Filedata * filedata)
19023 {
19024 if (filedata)
19025 {
19026 if (filedata->handle)
19027 fclose (filedata->handle);
19028 free (filedata);
19029 }
19030 }
19031
19032 void
19033 close_debug_file (void * data)
19034 {
19035 close_file ((Filedata *) data);
19036 }
19037
19038 static Filedata *
19039 open_file (const char * pathname)
19040 {
19041 struct stat statbuf;
19042 Filedata * filedata = NULL;
19043
19044 if (stat (pathname, & statbuf) < 0
19045 || ! S_ISREG (statbuf.st_mode))
19046 goto fail;
19047
19048 filedata = calloc (1, sizeof * filedata);
19049 if (filedata == NULL)
19050 goto fail;
19051
19052 filedata->handle = fopen (pathname, "rb");
19053 if (filedata->handle == NULL)
19054 goto fail;
19055
19056 filedata->file_size = (bfd_size_type) statbuf.st_size;
19057 filedata->file_name = pathname;
19058
19059 if (! get_file_header (filedata))
19060 goto fail;
19061
19062 if (filedata->file_header.e_shoff)
19063 {
19064 bfd_boolean res;
19065
19066 /* Read the section headers again, this time for real. */
19067 if (is_32bit_elf)
19068 res = get_32bit_section_headers (filedata, FALSE);
19069 else
19070 res = get_64bit_section_headers (filedata, FALSE);
19071
19072 if (!res)
19073 goto fail;
19074 }
19075
19076 return filedata;
19077
19078 fail:
19079 if (filedata)
19080 {
19081 if (filedata->handle)
19082 fclose (filedata->handle);
19083 free (filedata);
19084 }
19085 return NULL;
19086 }
19087
19088 void *
19089 open_debug_file (const char * pathname)
19090 {
19091 return open_file (pathname);
19092 }
19093
19094 /* Process one ELF object file according to the command line options.
19095 This file may actually be stored in an archive. The file is
19096 positioned at the start of the ELF object. Returns TRUE if no
19097 problems were encountered, FALSE otherwise. */
19098
19099 static bfd_boolean
19100 process_object (Filedata * filedata)
19101 {
19102 Filedata * separates;
19103 unsigned int i;
19104 bfd_boolean res = TRUE;
19105
19106 if (! get_file_header (filedata))
19107 {
19108 error (_("%s: Failed to read file header\n"), filedata->file_name);
19109 return FALSE;
19110 }
19111
19112 /* Initialise per file variables. */
19113 for (i = ARRAY_SIZE (version_info); i--;)
19114 version_info[i] = 0;
19115
19116 for (i = ARRAY_SIZE (dynamic_info); i--;)
19117 dynamic_info[i] = 0;
19118 dynamic_info_DT_GNU_HASH = 0;
19119
19120 /* Process the file. */
19121 if (show_name)
19122 printf (_("\nFile: %s\n"), filedata->file_name);
19123
19124 /* Initialise the dump_sects array from the cmdline_dump_sects array.
19125 Note we do this even if cmdline_dump_sects is empty because we
19126 must make sure that the dump_sets array is zeroed out before each
19127 object file is processed. */
19128 if (filedata->num_dump_sects > cmdline.num_dump_sects)
19129 memset (filedata->dump_sects, 0, filedata->num_dump_sects * sizeof (* filedata->dump_sects));
19130
19131 if (cmdline.num_dump_sects > 0)
19132 {
19133 if (filedata->num_dump_sects == 0)
19134 /* A sneaky way of allocating the dump_sects array. */
19135 request_dump_bynumber (filedata, cmdline.num_dump_sects, 0);
19136
19137 assert (filedata->num_dump_sects >= cmdline.num_dump_sects);
19138 memcpy (filedata->dump_sects, cmdline.dump_sects,
19139 cmdline.num_dump_sects * sizeof (* filedata->dump_sects));
19140 }
19141
19142 if (! process_file_header (filedata))
19143 return FALSE;
19144
19145 if (! process_section_headers (filedata))
19146 {
19147 /* Without loaded section headers we cannot process lots of things. */
19148 do_unwind = do_version = do_dump = do_arch = FALSE;
19149
19150 if (! do_using_dynamic)
19151 do_syms = do_dyn_syms = do_reloc = FALSE;
19152 }
19153
19154 if (! process_section_groups (filedata))
19155 /* Without loaded section groups we cannot process unwind. */
19156 do_unwind = FALSE;
19157
19158 if (process_program_headers (filedata))
19159 process_dynamic_section (filedata);
19160 else
19161 res = FALSE;
19162
19163 if (! process_relocs (filedata))
19164 res = FALSE;
19165
19166 if (! process_unwind (filedata))
19167 res = FALSE;
19168
19169 if (! process_symbol_table (filedata))
19170 res = FALSE;
19171
19172 if (! process_syminfo (filedata))
19173 res = FALSE;
19174
19175 if (! process_version_sections (filedata))
19176 res = FALSE;
19177
19178 if (filedata->file_header.e_shstrndx != SHN_UNDEF)
19179 separates = load_separate_debug_file (filedata, filedata->file_name);
19180 else
19181 separates = NULL;
19182
19183 if (! process_section_contents (filedata))
19184 res = FALSE;
19185
19186 if (separates)
19187 {
19188 if (! process_section_headers (separates))
19189 res = FALSE;
19190 else if (! process_section_contents (separates))
19191 res = FALSE;
19192 }
19193
19194 if (! process_notes (filedata))
19195 res = FALSE;
19196
19197 if (! process_gnu_liblist (filedata))
19198 res = FALSE;
19199
19200 if (! process_arch_specific (filedata))
19201 res = FALSE;
19202
19203 free (filedata->program_headers);
19204 filedata->program_headers = NULL;
19205
19206 free (filedata->section_headers);
19207 filedata->section_headers = NULL;
19208
19209 free (filedata->string_table);
19210 filedata->string_table = NULL;
19211 filedata->string_table_length = 0;
19212
19213 if (dynamic_strings)
19214 {
19215 free (dynamic_strings);
19216 dynamic_strings = NULL;
19217 dynamic_strings_length = 0;
19218 }
19219
19220 if (dynamic_symbols)
19221 {
19222 free (dynamic_symbols);
19223 dynamic_symbols = NULL;
19224 num_dynamic_syms = 0;
19225 }
19226
19227 if (dynamic_syminfo)
19228 {
19229 free (dynamic_syminfo);
19230 dynamic_syminfo = NULL;
19231 }
19232
19233 if (dynamic_section)
19234 {
19235 free (dynamic_section);
19236 dynamic_section = NULL;
19237 }
19238
19239 if (section_headers_groups)
19240 {
19241 free (section_headers_groups);
19242 section_headers_groups = NULL;
19243 }
19244
19245 if (section_groups)
19246 {
19247 struct group_list * g;
19248 struct group_list * next;
19249
19250 for (i = 0; i < group_count; i++)
19251 {
19252 for (g = section_groups [i].root; g != NULL; g = next)
19253 {
19254 next = g->next;
19255 free (g);
19256 }
19257 }
19258
19259 free (section_groups);
19260 section_groups = NULL;
19261 }
19262
19263 free_debug_memory ();
19264
19265 return res;
19266 }
19267
19268 /* Process an ELF archive.
19269 On entry the file is positioned just after the ARMAG string.
19270 Returns TRUE upon success, FALSE otherwise. */
19271
19272 static bfd_boolean
19273 process_archive (Filedata * filedata, bfd_boolean is_thin_archive)
19274 {
19275 struct archive_info arch;
19276 struct archive_info nested_arch;
19277 size_t got;
19278 bfd_boolean ret = TRUE;
19279
19280 show_name = TRUE;
19281
19282 /* The ARCH structure is used to hold information about this archive. */
19283 arch.file_name = NULL;
19284 arch.file = NULL;
19285 arch.index_array = NULL;
19286 arch.sym_table = NULL;
19287 arch.longnames = NULL;
19288
19289 /* The NESTED_ARCH structure is used as a single-item cache of information
19290 about a nested archive (when members of a thin archive reside within
19291 another regular archive file). */
19292 nested_arch.file_name = NULL;
19293 nested_arch.file = NULL;
19294 nested_arch.index_array = NULL;
19295 nested_arch.sym_table = NULL;
19296 nested_arch.longnames = NULL;
19297
19298 if (setup_archive (&arch, filedata->file_name, filedata->handle,
19299 is_thin_archive, do_archive_index) != 0)
19300 {
19301 ret = FALSE;
19302 goto out;
19303 }
19304
19305 if (do_archive_index)
19306 {
19307 if (arch.sym_table == NULL)
19308 error (_("%s: unable to dump the index as none was found\n"), filedata->file_name);
19309 else
19310 {
19311 unsigned long i, l;
19312 unsigned long current_pos;
19313
19314 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
19315 filedata->file_name, (unsigned long) arch.index_num, arch.sym_size);
19316
19317 current_pos = ftell (filedata->handle);
19318
19319 for (i = l = 0; i < arch.index_num; i++)
19320 {
19321 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
19322 {
19323 char * member_name;
19324
19325 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
19326
19327 if (member_name != NULL)
19328 {
19329 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
19330
19331 if (qualified_name != NULL)
19332 {
19333 printf (_("Contents of binary %s at offset "), qualified_name);
19334 (void) print_vma (arch.index_array[i], PREFIX_HEX);
19335 putchar ('\n');
19336 free (qualified_name);
19337 }
19338 }
19339 }
19340
19341 if (l >= arch.sym_size)
19342 {
19343 error (_("%s: end of the symbol table reached before the end of the index\n"),
19344 filedata->file_name);
19345 ret = FALSE;
19346 break;
19347 }
19348 /* PR 17531: file: 0b6630b2. */
19349 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
19350 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
19351 }
19352
19353 if (arch.uses_64bit_indices)
19354 l = (l + 7) & ~ 7;
19355 else
19356 l += l & 1;
19357
19358 if (l < arch.sym_size)
19359 {
19360 error (ngettext ("%s: %ld byte remains in the symbol table, "
19361 "but without corresponding entries in "
19362 "the index table\n",
19363 "%s: %ld bytes remain in the symbol table, "
19364 "but without corresponding entries in "
19365 "the index table\n",
19366 arch.sym_size - l),
19367 filedata->file_name, arch.sym_size - l);
19368 ret = FALSE;
19369 }
19370
19371 if (fseek (filedata->handle, current_pos, SEEK_SET) != 0)
19372 {
19373 error (_("%s: failed to seek back to start of object files in the archive\n"),
19374 filedata->file_name);
19375 ret = FALSE;
19376 goto out;
19377 }
19378 }
19379
19380 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
19381 && !do_segments && !do_header && !do_dump && !do_version
19382 && !do_histogram && !do_debugging && !do_arch && !do_notes
19383 && !do_section_groups && !do_dyn_syms)
19384 {
19385 ret = TRUE; /* Archive index only. */
19386 goto out;
19387 }
19388 }
19389
19390 while (1)
19391 {
19392 char * name;
19393 size_t namelen;
19394 char * qualified_name;
19395
19396 /* Read the next archive header. */
19397 if (fseek (filedata->handle, arch.next_arhdr_offset, SEEK_SET) != 0)
19398 {
19399 error (_("%s: failed to seek to next archive header\n"), filedata->file_name);
19400 return FALSE;
19401 }
19402 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, filedata->handle);
19403 if (got != sizeof arch.arhdr)
19404 {
19405 if (got == 0)
19406 break;
19407 error (_("%s: failed to read archive header\n"), filedata->file_name);
19408 ret = FALSE;
19409 break;
19410 }
19411 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
19412 {
19413 error (_("%s: did not find a valid archive header\n"), arch.file_name);
19414 ret = FALSE;
19415 break;
19416 }
19417
19418 arch.next_arhdr_offset += sizeof arch.arhdr;
19419
19420 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
19421 if (archive_file_size & 01)
19422 ++archive_file_size;
19423
19424 name = get_archive_member_name (&arch, &nested_arch);
19425 if (name == NULL)
19426 {
19427 error (_("%s: bad archive file name\n"), filedata->file_name);
19428 ret = FALSE;
19429 break;
19430 }
19431 namelen = strlen (name);
19432
19433 qualified_name = make_qualified_name (&arch, &nested_arch, name);
19434 if (qualified_name == NULL)
19435 {
19436 error (_("%s: bad archive file name\n"), filedata->file_name);
19437 ret = FALSE;
19438 break;
19439 }
19440
19441 if (is_thin_archive && arch.nested_member_origin == 0)
19442 {
19443 /* This is a proxy for an external member of a thin archive. */
19444 Filedata * member_filedata;
19445 char * member_file_name = adjust_relative_path
19446 (filedata->file_name, name, namelen);
19447
19448 if (member_file_name == NULL)
19449 {
19450 ret = FALSE;
19451 break;
19452 }
19453
19454 member_filedata = open_file (member_file_name);
19455 if (member_filedata == NULL)
19456 {
19457 error (_("Input file '%s' is not readable.\n"), member_file_name);
19458 free (member_file_name);
19459 ret = FALSE;
19460 break;
19461 }
19462
19463 archive_file_offset = arch.nested_member_origin;
19464 member_filedata->file_name = qualified_name;
19465
19466 if (! process_object (member_filedata))
19467 ret = FALSE;
19468
19469 close_file (member_filedata);
19470 free (member_file_name);
19471 }
19472 else if (is_thin_archive)
19473 {
19474 Filedata thin_filedata;
19475
19476 memset (&thin_filedata, 0, sizeof (thin_filedata));
19477
19478 /* PR 15140: Allow for corrupt thin archives. */
19479 if (nested_arch.file == NULL)
19480 {
19481 error (_("%s: contains corrupt thin archive: %s\n"),
19482 filedata->file_name, name);
19483 ret = FALSE;
19484 break;
19485 }
19486
19487 /* This is a proxy for a member of a nested archive. */
19488 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
19489
19490 /* The nested archive file will have been opened and setup by
19491 get_archive_member_name. */
19492 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
19493 {
19494 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
19495 ret = FALSE;
19496 break;
19497 }
19498
19499 thin_filedata.handle = nested_arch.file;
19500 thin_filedata.file_name = qualified_name;
19501
19502 if (! process_object (& thin_filedata))
19503 ret = FALSE;
19504 }
19505 else
19506 {
19507 archive_file_offset = arch.next_arhdr_offset;
19508 arch.next_arhdr_offset += archive_file_size;
19509
19510 filedata->file_name = qualified_name;
19511 if (! process_object (filedata))
19512 ret = FALSE;
19513 }
19514
19515 if (filedata->dump_sects != NULL)
19516 {
19517 free (filedata->dump_sects);
19518 filedata->dump_sects = NULL;
19519 filedata->num_dump_sects = 0;
19520 }
19521
19522 free (qualified_name);
19523 }
19524
19525 out:
19526 if (nested_arch.file != NULL)
19527 fclose (nested_arch.file);
19528 release_archive (&nested_arch);
19529 release_archive (&arch);
19530
19531 return ret;
19532 }
19533
19534 static bfd_boolean
19535 process_file (char * file_name)
19536 {
19537 Filedata * filedata = NULL;
19538 struct stat statbuf;
19539 char armag[SARMAG];
19540 bfd_boolean ret = TRUE;
19541
19542 if (stat (file_name, &statbuf) < 0)
19543 {
19544 if (errno == ENOENT)
19545 error (_("'%s': No such file\n"), file_name);
19546 else
19547 error (_("Could not locate '%s'. System error message: %s\n"),
19548 file_name, strerror (errno));
19549 return FALSE;
19550 }
19551
19552 if (! S_ISREG (statbuf.st_mode))
19553 {
19554 error (_("'%s' is not an ordinary file\n"), file_name);
19555 return FALSE;
19556 }
19557
19558 filedata = calloc (1, sizeof * filedata);
19559 if (filedata == NULL)
19560 {
19561 error (_("Out of memory allocating file data structure\n"));
19562 return FALSE;
19563 }
19564
19565 filedata->file_name = file_name;
19566 filedata->handle = fopen (file_name, "rb");
19567 if (filedata->handle == NULL)
19568 {
19569 error (_("Input file '%s' is not readable.\n"), file_name);
19570 free (filedata);
19571 return FALSE;
19572 }
19573
19574 if (fread (armag, SARMAG, 1, filedata->handle) != 1)
19575 {
19576 error (_("%s: Failed to read file's magic number\n"), file_name);
19577 fclose (filedata->handle);
19578 free (filedata);
19579 return FALSE;
19580 }
19581
19582 filedata->file_size = (bfd_size_type) statbuf.st_size;
19583
19584 if (memcmp (armag, ARMAG, SARMAG) == 0)
19585 {
19586 if (! process_archive (filedata, FALSE))
19587 ret = FALSE;
19588 }
19589 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
19590 {
19591 if ( ! process_archive (filedata, TRUE))
19592 ret = FALSE;
19593 }
19594 else
19595 {
19596 if (do_archive_index)
19597 error (_("File %s is not an archive so its index cannot be displayed.\n"),
19598 file_name);
19599
19600 rewind (filedata->handle);
19601 archive_file_size = archive_file_offset = 0;
19602
19603 if (! process_object (filedata))
19604 ret = FALSE;
19605 }
19606
19607 fclose (filedata->handle);
19608 free (filedata);
19609
19610 return ret;
19611 }
19612
19613 #ifdef SUPPORT_DISASSEMBLY
19614 /* Needed by the i386 disassembler. For extra credit, someone could
19615 fix this so that we insert symbolic addresses here, esp for GOT/PLT
19616 symbols. */
19617
19618 void
19619 print_address (unsigned int addr, FILE * outfile)
19620 {
19621 fprintf (outfile,"0x%8.8x", addr);
19622 }
19623
19624 /* Needed by the i386 disassembler. */
19625
19626 void
19627 db_task_printsym (unsigned int addr)
19628 {
19629 print_address (addr, stderr);
19630 }
19631 #endif
19632
19633 int
19634 main (int argc, char ** argv)
19635 {
19636 int err;
19637
19638 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
19639 setlocale (LC_MESSAGES, "");
19640 #endif
19641 #if defined (HAVE_SETLOCALE)
19642 setlocale (LC_CTYPE, "");
19643 #endif
19644 bindtextdomain (PACKAGE, LOCALEDIR);
19645 textdomain (PACKAGE);
19646
19647 expandargv (&argc, &argv);
19648
19649 cmdline.file_name = "<cmdline>";
19650 parse_args (& cmdline, argc, argv);
19651
19652 if (optind < (argc - 1))
19653 show_name = TRUE;
19654 else if (optind >= argc)
19655 {
19656 warn (_("Nothing to do.\n"));
19657 usage (stderr);
19658 }
19659
19660 err = FALSE;
19661 while (optind < argc)
19662 if (! process_file (argv[optind++]))
19663 err = TRUE;
19664
19665 if (cmdline.dump_sects != NULL)
19666 free (cmdline.dump_sects);
19667
19668 return err ? EXIT_FAILURE : EXIT_SUCCESS;
19669 }