?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
PR binutils/12329
[binutils.git] / binutils / readelf.c
blobc1bc2c5f8f40727dc2edcf091d04b961b0231d33
1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
3 2008, 2009, 2010, 2011
4 Free Software Foundation, Inc.
5
6 Originally developed by Eric Youngdale <eric@andante.jic.com>
7 Modifications by Nick Clifton <nickc@redhat.com>
8
9 This file is part of GNU Binutils.
10
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
15
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
20
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
23 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 02110-1301, USA. */
25 \f
26 /* The difference between readelf and objdump:
27
28 Both programs are capable of displaying the contents of ELF format files,
29 so why does the binutils project have two file dumpers ?
30
31 The reason is that objdump sees an ELF file through a BFD filter of the
32 world; if BFD has a bug where, say, it disagrees about a machine constant
33 in e_flags, then the odds are good that it will remain internally
34 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
35 GAS sees it the BFD way. There was need for a tool to go find out what
36 the file actually says.
37
38 This is why the readelf program does not link against the BFD library - it
39 exists as an independent program to help verify the correct working of BFD.
40
41 There is also the case that readelf can provide more information about an
42 ELF file than is provided by objdump. In particular it can display DWARF
43 debugging information which (at the moment) objdump cannot. */
44 \f
45 #include "config.h"
46 #include "sysdep.h"
47 #include <assert.h>
48 #include <sys/stat.h>
49 #include <time.h>
50 #ifdef HAVE_ZLIB_H
51 #include <zlib.h>
52 #endif
53
54 #if __GNUC__ >= 2
55 /* Define BFD64 here, even if our default architecture is 32 bit ELF
56 as this will allow us to read in and parse 64bit and 32bit ELF files.
57 Only do this if we believe that the compiler can support a 64 bit
58 data type. For now we only rely on GCC being able to do this. */
59 #define BFD64
60 #endif
61
62 #include "bfd.h"
63 #include "bucomm.h"
64 #include "elfcomm.h"
65 #include "dwarf.h"
66
67 #include "elf/common.h"
68 #include "elf/external.h"
69 #include "elf/internal.h"
70
71
72 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
73 we can obtain the H8 reloc numbers. We need these for the
74 get_reloc_size() function. We include h8.h again after defining
75 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
76
77 #include "elf/h8.h"
78 #undef _ELF_H8_H
79
80 /* Undo the effects of #including reloc-macros.h. */
81
82 #undef START_RELOC_NUMBERS
83 #undef RELOC_NUMBER
84 #undef FAKE_RELOC
85 #undef EMPTY_RELOC
86 #undef END_RELOC_NUMBERS
87 #undef _RELOC_MACROS_H
88
89 /* The following headers use the elf/reloc-macros.h file to
90 automatically generate relocation recognition functions
91 such as elf_mips_reloc_type() */
92
93 #define RELOC_MACROS_GEN_FUNC
94
95 #include "elf/alpha.h"
96 #include "elf/arc.h"
97 #include "elf/arm.h"
98 #include "elf/avr.h"
99 #include "elf/bfin.h"
100 #include "elf/cr16.h"
101 #include "elf/cris.h"
102 #include "elf/crx.h"
103 #include "elf/d10v.h"
104 #include "elf/d30v.h"
105 #include "elf/dlx.h"
106 #include "elf/fr30.h"
107 #include "elf/frv.h"
108 #include "elf/h8.h"
109 #include "elf/hppa.h"
110 #include "elf/i386.h"
111 #include "elf/i370.h"
112 #include "elf/i860.h"
113 #include "elf/i960.h"
114 #include "elf/ia64.h"
115 #include "elf/ip2k.h"
116 #include "elf/lm32.h"
117 #include "elf/iq2000.h"
118 #include "elf/m32c.h"
119 #include "elf/m32r.h"
120 #include "elf/m68k.h"
121 #include "elf/m68hc11.h"
122 #include "elf/mcore.h"
123 #include "elf/mep.h"
124 #include "elf/microblaze.h"
125 #include "elf/mips.h"
126 #include "elf/mmix.h"
127 #include "elf/mn10200.h"
128 #include "elf/mn10300.h"
129 #include "elf/moxie.h"
130 #include "elf/mt.h"
131 #include "elf/msp430.h"
132 #include "elf/or32.h"
133 #include "elf/pj.h"
134 #include "elf/ppc.h"
135 #include "elf/ppc64.h"
136 #include "elf/rx.h"
137 #include "elf/s390.h"
138 #include "elf/score.h"
139 #include "elf/sh.h"
140 #include "elf/sparc.h"
141 #include "elf/spu.h"
142 #include "elf/tic6x.h"
143 #include "elf/tilegx.h"
144 #include "elf/tilepro.h"
145 #include "elf/v850.h"
146 #include "elf/vax.h"
147 #include "elf/x86-64.h"
148 #include "elf/xc16x.h"
149 #include "elf/xstormy16.h"
150 #include "elf/xtensa.h"
151
152 #include "getopt.h"
153 #include "libiberty.h"
154 #include "safe-ctype.h"
155 #include "filenames.h"
156
157 char * program_name = "readelf";
158 static long archive_file_offset;
159 static unsigned long archive_file_size;
160 static unsigned long dynamic_addr;
161 static bfd_size_type dynamic_size;
162 static unsigned int dynamic_nent;
163 static char * dynamic_strings;
164 static unsigned long dynamic_strings_length;
165 static char * string_table;
166 static unsigned long string_table_length;
167 static unsigned long num_dynamic_syms;
168 static Elf_Internal_Sym * dynamic_symbols;
169 static Elf_Internal_Syminfo * dynamic_syminfo;
170 static unsigned long dynamic_syminfo_offset;
171 static unsigned int dynamic_syminfo_nent;
172 static char program_interpreter[PATH_MAX];
173 static bfd_vma dynamic_info[DT_ENCODING];
174 static bfd_vma dynamic_info_DT_GNU_HASH;
175 static bfd_vma version_info[16];
176 static Elf_Internal_Ehdr elf_header;
177 static Elf_Internal_Shdr * section_headers;
178 static Elf_Internal_Phdr * program_headers;
179 static Elf_Internal_Dyn * dynamic_section;
180 static Elf_Internal_Shdr * symtab_shndx_hdr;
181 static int show_name;
182 static int do_dynamic;
183 static int do_syms;
184 static int do_dyn_syms;
185 static int do_reloc;
186 static int do_sections;
187 static int do_section_groups;
188 static int do_section_details;
189 static int do_segments;
190 static int do_unwind;
191 static int do_using_dynamic;
192 static int do_header;
193 static int do_dump;
194 static int do_version;
195 static int do_histogram;
196 static int do_debugging;
197 static int do_arch;
198 static int do_notes;
199 static int do_archive_index;
200 static int is_32bit_elf;
201
202 struct group_list
203 {
204 struct group_list * next;
205 unsigned int section_index;
206 };
207
208 struct group
209 {
210 struct group_list * root;
211 unsigned int group_index;
212 };
213
214 static size_t group_count;
215 static struct group * section_groups;
216 static struct group ** section_headers_groups;
217
218
219 /* Flag bits indicating particular types of dump. */
220 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
221 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
222 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
223 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
224 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
225
226 typedef unsigned char dump_type;
227
228 /* A linked list of the section names for which dumps were requested. */
229 struct dump_list_entry
230 {
231 char * name;
232 dump_type type;
233 struct dump_list_entry * next;
234 };
235 static struct dump_list_entry * dump_sects_byname;
236
237 /* A dynamic array of flags indicating for which sections a dump
238 has been requested via command line switches. */
239 static dump_type * cmdline_dump_sects = NULL;
240 static unsigned int num_cmdline_dump_sects = 0;
241
242 /* A dynamic array of flags indicating for which sections a dump of
243 some kind has been requested. It is reset on a per-object file
244 basis and then initialised from the cmdline_dump_sects array,
245 the results of interpreting the -w switch, and the
246 dump_sects_byname list. */
247 static dump_type * dump_sects = NULL;
248 static unsigned int num_dump_sects = 0;
249
250
251 /* How to print a vma value. */
252 typedef enum print_mode
253 {
254 HEX,
255 DEC,
256 DEC_5,
257 UNSIGNED,
258 PREFIX_HEX,
259 FULL_HEX,
260 LONG_HEX
261 }
262 print_mode;
263
264 #define UNKNOWN -1
265
266 #define SECTION_NAME(X) \
267 ((X) == NULL ? _("<none>") \
268 : string_table == NULL ? _("<no-name>") \
269 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
270 : string_table + (X)->sh_name))
271
272 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
273
274 #define GET_ELF_SYMBOLS(file, section) \
275 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
276 : get_64bit_elf_symbols (file, section))
277
278 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
279 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
280 already been called and verified that the string exists. */
281 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
282
283 #define REMOVE_ARCH_BITS(ADDR) \
284 do \
285 { \
286 if (elf_header.e_machine == EM_ARM) \
287 (ADDR) &= ~1; \
288 } \
289 while (0)
290 \f
291 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET.
292 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
293 using malloc and fill that. In either case return the pointer to the start of
294 the retrieved data or NULL if something went wrong. If something does go wrong
295 emit an error message using REASON as part of the context. */
296
297 static void *
298 get_data (void * var, FILE * file, long offset, size_t size, size_t nmemb,
299 const char * reason)
300 {
301 void * mvar;
302
303 if (size == 0 || nmemb == 0)
304 return NULL;
305
306 if (fseek (file, archive_file_offset + offset, SEEK_SET))
307 {
308 error (_("Unable to seek to 0x%lx for %s\n"),
309 (unsigned long) archive_file_offset + offset, reason);
310 return NULL;
311 }
312
313 mvar = var;
314 if (mvar == NULL)
315 {
316 /* Check for overflow. */
317 if (nmemb < (~(size_t) 0 - 1) / size)
318 /* + 1 so that we can '\0' terminate invalid string table sections. */
319 mvar = malloc (size * nmemb + 1);
320
321 if (mvar == NULL)
322 {
323 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
324 (unsigned long)(size * nmemb), reason);
325 return NULL;
326 }
327
328 ((char *) mvar)[size * nmemb] = '\0';
329 }
330
331 if (fread (mvar, size, nmemb, file) != nmemb)
332 {
333 error (_("Unable to read in 0x%lx bytes of %s\n"),
334 (unsigned long)(size * nmemb), reason);
335 if (mvar != var)
336 free (mvar);
337 return NULL;
338 }
339
340 return mvar;
341 }
342
343 /* Print a VMA value. */
344
345 static int
346 print_vma (bfd_vma vma, print_mode mode)
347 {
348 int nc = 0;
349
350 switch (mode)
351 {
352 case FULL_HEX:
353 nc = printf ("0x");
354 /* Drop through. */
355
356 case LONG_HEX:
357 #ifdef BFD64
358 if (is_32bit_elf)
359 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
360 #endif
361 printf_vma (vma);
362 return nc + 16;
363
364 case DEC_5:
365 if (vma <= 99999)
366 return printf ("%5" BFD_VMA_FMT "d", vma);
367 /* Drop through. */
368
369 case PREFIX_HEX:
370 nc = printf ("0x");
371 /* Drop through. */
372
373 case HEX:
374 return nc + printf ("%" BFD_VMA_FMT "x", vma);
375
376 case DEC:
377 return printf ("%" BFD_VMA_FMT "d", vma);
378
379 case UNSIGNED:
380 return printf ("%" BFD_VMA_FMT "u", vma);
381 }
382 return 0;
383 }
384
385 /* Display a symbol on stdout. Handles the display of non-printing characters.
386
387 If DO_WIDE is not true then format the symbol to be at most WIDTH characters,
388 truncating as necessary. If WIDTH is negative then format the string to be
389 exactly - WIDTH characters, truncating or padding as necessary.
390
391 Returns the number of emitted characters. */
392
393 static unsigned int
394 print_symbol (int width, const char *symbol)
395 {
396 const char *c;
397 bfd_boolean extra_padding = FALSE;
398 unsigned int num_printed = 0;
399
400 if (do_wide)
401 {
402 /* Set the width to a very large value. This simplifies the
403 code below. */
404 width = INT_MAX;
405 }
406 else if (width < 0)
407 {
408 /* Keep the width positive. This also helps. */
409 width = - width;
410 extra_padding = TRUE;
411 }
412
413 while (width)
414 {
415 int len;
416
417 c = symbol;
418
419 /* Look for non-printing symbols inside the symbol's name.
420 This test is triggered in particular by the names generated
421 by the assembler for local labels. */
422 while (ISPRINT (*c))
423 c++;
424
425 len = c - symbol;
426
427 if (len)
428 {
429 if (len > width)
430 len = width;
431
432 printf ("%.*s", len, symbol);
433
434 width -= len;
435 num_printed += len;
436 }
437
438 if (*c == 0 || width == 0)
439 break;
440
441 /* Now display the non-printing character, if
442 there is room left in which to dipslay it. */
443 if ((unsigned char) *c < 32)
444 {
445 if (width < 2)
446 break;
447
448 printf ("^%c", *c + 0x40);
449
450 width -= 2;
451 num_printed += 2;
452 }
453 else
454 {
455 if (width < 6)
456 break;
457
458 printf ("<0x%.2x>", (unsigned char) *c);
459
460 width -= 6;
461 num_printed += 6;
462 }
463
464 symbol = c + 1;
465 }
466
467 if (extra_padding && width > 0)
468 {
469 /* Fill in the remaining spaces. */
470 printf ("%-*s", width, " ");
471 num_printed += 2;
472 }
473
474 return num_printed;
475 }
476
477 /* Return a pointer to section NAME, or NULL if no such section exists. */
478
479 static Elf_Internal_Shdr *
480 find_section (const char * name)
481 {
482 unsigned int i;
483
484 for (i = 0; i < elf_header.e_shnum; i++)
485 if (streq (SECTION_NAME (section_headers + i), name))
486 return section_headers + i;
487
488 return NULL;
489 }
490
491 /* Return a pointer to a section containing ADDR, or NULL if no such
492 section exists. */
493
494 static Elf_Internal_Shdr *
495 find_section_by_address (bfd_vma addr)
496 {
497 unsigned int i;
498
499 for (i = 0; i < elf_header.e_shnum; i++)
500 {
501 Elf_Internal_Shdr *sec = section_headers + i;
502 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
503 return sec;
504 }
505
506 return NULL;
507 }
508
509 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
510 bytes read. */
511
512 static unsigned long
513 read_uleb128 (unsigned char *data, unsigned int *length_return)
514 {
515 return read_leb128 (data, length_return, 0);
516 }
517
518 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
519 This OS has so many departures from the ELF standard that we test it at
520 many places. */
521
522 static inline int
523 is_ia64_vms (void)
524 {
525 return elf_header.e_machine == EM_IA_64
526 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
527 }
528
529 /* Guess the relocation size commonly used by the specific machines. */
530
531 static int
532 guess_is_rela (unsigned int e_machine)
533 {
534 switch (e_machine)
535 {
536 /* Targets that use REL relocations. */
537 case EM_386:
538 case EM_486:
539 case EM_960:
540 case EM_ARM:
541 case EM_D10V:
542 case EM_CYGNUS_D10V:
543 case EM_DLX:
544 case EM_MIPS:
545 case EM_MIPS_RS3_LE:
546 case EM_CYGNUS_M32R:
547 case EM_OPENRISC:
548 case EM_OR32:
549 case EM_SCORE:
550 return FALSE;
551
552 /* Targets that use RELA relocations. */
553 case EM_68K:
554 case EM_860:
555 case EM_ALPHA:
556 case EM_ALTERA_NIOS2:
557 case EM_AVR:
558 case EM_AVR_OLD:
559 case EM_BLACKFIN:
560 case EM_CR16:
561 case EM_CR16_OLD:
562 case EM_CRIS:
563 case EM_CRX:
564 case EM_D30V:
565 case EM_CYGNUS_D30V:
566 case EM_FR30:
567 case EM_CYGNUS_FR30:
568 case EM_CYGNUS_FRV:
569 case EM_H8S:
570 case EM_H8_300:
571 case EM_H8_300H:
572 case EM_IA_64:
573 case EM_IP2K:
574 case EM_IP2K_OLD:
575 case EM_IQ2000:
576 case EM_LATTICEMICO32:
577 case EM_M32C_OLD:
578 case EM_M32C:
579 case EM_M32R:
580 case EM_MCORE:
581 case EM_CYGNUS_MEP:
582 case EM_MMIX:
583 case EM_MN10200:
584 case EM_CYGNUS_MN10200:
585 case EM_MN10300:
586 case EM_CYGNUS_MN10300:
587 case EM_MOXIE:
588 case EM_MSP430:
589 case EM_MSP430_OLD:
590 case EM_MT:
591 case EM_NIOS32:
592 case EM_PPC64:
593 case EM_PPC:
594 case EM_RX:
595 case EM_S390:
596 case EM_S390_OLD:
597 case EM_SH:
598 case EM_SPARC:
599 case EM_SPARC32PLUS:
600 case EM_SPARCV9:
601 case EM_SPU:
602 case EM_TI_C6000:
603 case EM_TILEGX:
604 case EM_TILEPRO:
605 case EM_V850:
606 case EM_CYGNUS_V850:
607 case EM_VAX:
608 case EM_X86_64:
609 case EM_L1OM:
610 case EM_XSTORMY16:
611 case EM_XTENSA:
612 case EM_XTENSA_OLD:
613 case EM_MICROBLAZE:
614 case EM_MICROBLAZE_OLD:
615 return TRUE;
616
617 case EM_68HC05:
618 case EM_68HC08:
619 case EM_68HC11:
620 case EM_68HC16:
621 case EM_FX66:
622 case EM_ME16:
623 case EM_MMA:
624 case EM_NCPU:
625 case EM_NDR1:
626 case EM_PCP:
627 case EM_ST100:
628 case EM_ST19:
629 case EM_ST7:
630 case EM_ST9PLUS:
631 case EM_STARCORE:
632 case EM_SVX:
633 case EM_TINYJ:
634 default:
635 warn (_("Don't know about relocations on this machine architecture\n"));
636 return FALSE;
637 }
638 }
639
640 static int
641 slurp_rela_relocs (FILE * file,
642 unsigned long rel_offset,
643 unsigned long rel_size,
644 Elf_Internal_Rela ** relasp,
645 unsigned long * nrelasp)
646 {
647 Elf_Internal_Rela * relas;
648 unsigned long nrelas;
649 unsigned int i;
650
651 if (is_32bit_elf)
652 {
653 Elf32_External_Rela * erelas;
654
655 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
656 rel_size, _("relocs"));
657 if (!erelas)
658 return 0;
659
660 nrelas = rel_size / sizeof (Elf32_External_Rela);
661
662 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
663 sizeof (Elf_Internal_Rela));
664
665 if (relas == NULL)
666 {
667 free (erelas);
668 error (_("out of memory parsing relocs\n"));
669 return 0;
670 }
671
672 for (i = 0; i < nrelas; i++)
673 {
674 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
675 relas[i].r_info = BYTE_GET (erelas[i].r_info);
676 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
677 }
678
679 free (erelas);
680 }
681 else
682 {
683 Elf64_External_Rela * erelas;
684
685 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
686 rel_size, _("relocs"));
687 if (!erelas)
688 return 0;
689
690 nrelas = rel_size / sizeof (Elf64_External_Rela);
691
692 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
693 sizeof (Elf_Internal_Rela));
694
695 if (relas == NULL)
696 {
697 free (erelas);
698 error (_("out of memory parsing relocs\n"));
699 return 0;
700 }
701
702 for (i = 0; i < nrelas; i++)
703 {
704 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
705 relas[i].r_info = BYTE_GET (erelas[i].r_info);
706 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
707
708 /* The #ifdef BFD64 below is to prevent a compile time
709 warning. We know that if we do not have a 64 bit data
710 type that we will never execute this code anyway. */
711 #ifdef BFD64
712 if (elf_header.e_machine == EM_MIPS
713 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
714 {
715 /* In little-endian objects, r_info isn't really a
716 64-bit little-endian value: it has a 32-bit
717 little-endian symbol index followed by four
718 individual byte fields. Reorder INFO
719 accordingly. */
720 bfd_vma inf = relas[i].r_info;
721 inf = (((inf & 0xffffffff) << 32)
722 | ((inf >> 56) & 0xff)
723 | ((inf >> 40) & 0xff00)
724 | ((inf >> 24) & 0xff0000)
725 | ((inf >> 8) & 0xff000000));
726 relas[i].r_info = inf;
727 }
728 #endif /* BFD64 */
729 }
730
731 free (erelas);
732 }
733 *relasp = relas;
734 *nrelasp = nrelas;
735 return 1;
736 }
737
738 static int
739 slurp_rel_relocs (FILE * file,
740 unsigned long rel_offset,
741 unsigned long rel_size,
742 Elf_Internal_Rela ** relsp,
743 unsigned long * nrelsp)
744 {
745 Elf_Internal_Rela * rels;
746 unsigned long nrels;
747 unsigned int i;
748
749 if (is_32bit_elf)
750 {
751 Elf32_External_Rel * erels;
752
753 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
754 rel_size, _("relocs"));
755 if (!erels)
756 return 0;
757
758 nrels = rel_size / sizeof (Elf32_External_Rel);
759
760 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
761
762 if (rels == NULL)
763 {
764 free (erels);
765 error (_("out of memory parsing relocs\n"));
766 return 0;
767 }
768
769 for (i = 0; i < nrels; i++)
770 {
771 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
772 rels[i].r_info = BYTE_GET (erels[i].r_info);
773 rels[i].r_addend = 0;
774 }
775
776 free (erels);
777 }
778 else
779 {
780 Elf64_External_Rel * erels;
781
782 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
783 rel_size, _("relocs"));
784 if (!erels)
785 return 0;
786
787 nrels = rel_size / sizeof (Elf64_External_Rel);
788
789 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
790
791 if (rels == NULL)
792 {
793 free (erels);
794 error (_("out of memory parsing relocs\n"));
795 return 0;
796 }
797
798 for (i = 0; i < nrels; i++)
799 {
800 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
801 rels[i].r_info = BYTE_GET (erels[i].r_info);
802 rels[i].r_addend = 0;
803
804 /* The #ifdef BFD64 below is to prevent a compile time
805 warning. We know that if we do not have a 64 bit data
806 type that we will never execute this code anyway. */
807 #ifdef BFD64
808 if (elf_header.e_machine == EM_MIPS
809 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
810 {
811 /* In little-endian objects, r_info isn't really a
812 64-bit little-endian value: it has a 32-bit
813 little-endian symbol index followed by four
814 individual byte fields. Reorder INFO
815 accordingly. */
816 bfd_vma inf = rels[i].r_info;
817 inf = (((inf & 0xffffffff) << 32)
818 | ((inf >> 56) & 0xff)
819 | ((inf >> 40) & 0xff00)
820 | ((inf >> 24) & 0xff0000)
821 | ((inf >> 8) & 0xff000000));
822 rels[i].r_info = inf;
823 }
824 #endif /* BFD64 */
825 }
826
827 free (erels);
828 }
829 *relsp = rels;
830 *nrelsp = nrels;
831 return 1;
832 }
833
834 /* Returns the reloc type extracted from the reloc info field. */
835
836 static unsigned int
837 get_reloc_type (bfd_vma reloc_info)
838 {
839 if (is_32bit_elf)
840 return ELF32_R_TYPE (reloc_info);
841
842 switch (elf_header.e_machine)
843 {
844 case EM_MIPS:
845 /* Note: We assume that reloc_info has already been adjusted for us. */
846 return ELF64_MIPS_R_TYPE (reloc_info);
847
848 case EM_SPARCV9:
849 return ELF64_R_TYPE_ID (reloc_info);
850
851 default:
852 return ELF64_R_TYPE (reloc_info);
853 }
854 }
855
856 /* Return the symbol index extracted from the reloc info field. */
857
858 static bfd_vma
859 get_reloc_symindex (bfd_vma reloc_info)
860 {
861 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
862 }
863
864 /* Display the contents of the relocation data found at the specified
865 offset. */
866
867 static void
868 dump_relocations (FILE * file,
869 unsigned long rel_offset,
870 unsigned long rel_size,
871 Elf_Internal_Sym * symtab,
872 unsigned long nsyms,
873 char * strtab,
874 unsigned long strtablen,
875 int is_rela)
876 {
877 unsigned int i;
878 Elf_Internal_Rela * rels;
879
880 if (is_rela == UNKNOWN)
881 is_rela = guess_is_rela (elf_header.e_machine);
882
883 if (is_rela)
884 {
885 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
886 return;
887 }
888 else
889 {
890 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
891 return;
892 }
893
894 if (is_32bit_elf)
895 {
896 if (is_rela)
897 {
898 if (do_wide)
899 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
900 else
901 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
902 }
903 else
904 {
905 if (do_wide)
906 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
907 else
908 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
909 }
910 }
911 else
912 {
913 if (is_rela)
914 {
915 if (do_wide)
916 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
917 else
918 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
919 }
920 else
921 {
922 if (do_wide)
923 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
924 else
925 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
926 }
927 }
928
929 for (i = 0; i < rel_size; i++)
930 {
931 const char * rtype;
932 bfd_vma offset;
933 bfd_vma inf;
934 bfd_vma symtab_index;
935 bfd_vma type;
936
937 offset = rels[i].r_offset;
938 inf = rels[i].r_info;
939
940 type = get_reloc_type (inf);
941 symtab_index = get_reloc_symindex (inf);
942
943 if (is_32bit_elf)
944 {
945 printf ("%8.8lx %8.8lx ",
946 (unsigned long) offset & 0xffffffff,
947 (unsigned long) inf & 0xffffffff);
948 }
949 else
950 {
951 #if BFD_HOST_64BIT_LONG
952 printf (do_wide
953 ? "%16.16lx %16.16lx "
954 : "%12.12lx %12.12lx ",
955 offset, inf);
956 #elif BFD_HOST_64BIT_LONG_LONG
957 #ifndef __MSVCRT__
958 printf (do_wide
959 ? "%16.16llx %16.16llx "
960 : "%12.12llx %12.12llx ",
961 offset, inf);
962 #else
963 printf (do_wide
964 ? "%16.16I64x %16.16I64x "
965 : "%12.12I64x %12.12I64x ",
966 offset, inf);
967 #endif
968 #else
969 printf (do_wide
970 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
971 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
972 _bfd_int64_high (offset),
973 _bfd_int64_low (offset),
974 _bfd_int64_high (inf),
975 _bfd_int64_low (inf));
976 #endif
977 }
978
979 switch (elf_header.e_machine)
980 {
981 default:
982 rtype = NULL;
983 break;
984
985 case EM_M32R:
986 case EM_CYGNUS_M32R:
987 rtype = elf_m32r_reloc_type (type);
988 break;
989
990 case EM_386:
991 case EM_486:
992 rtype = elf_i386_reloc_type (type);
993 break;
994
995 case EM_68HC11:
996 case EM_68HC12:
997 rtype = elf_m68hc11_reloc_type (type);
998 break;
999
1000 case EM_68K:
1001 rtype = elf_m68k_reloc_type (type);
1002 break;
1003
1004 case EM_960:
1005 rtype = elf_i960_reloc_type (type);
1006 break;
1007
1008 case EM_AVR:
1009 case EM_AVR_OLD:
1010 rtype = elf_avr_reloc_type (type);
1011 break;
1012
1013 case EM_OLD_SPARCV9:
1014 case EM_SPARC32PLUS:
1015 case EM_SPARCV9:
1016 case EM_SPARC:
1017 rtype = elf_sparc_reloc_type (type);
1018 break;
1019
1020 case EM_SPU:
1021 rtype = elf_spu_reloc_type (type);
1022 break;
1023
1024 case EM_V850:
1025 case EM_CYGNUS_V850:
1026 rtype = v850_reloc_type (type);
1027 break;
1028
1029 case EM_D10V:
1030 case EM_CYGNUS_D10V:
1031 rtype = elf_d10v_reloc_type (type);
1032 break;
1033
1034 case EM_D30V:
1035 case EM_CYGNUS_D30V:
1036 rtype = elf_d30v_reloc_type (type);
1037 break;
1038
1039 case EM_DLX:
1040 rtype = elf_dlx_reloc_type (type);
1041 break;
1042
1043 case EM_SH:
1044 rtype = elf_sh_reloc_type (type);
1045 break;
1046
1047 case EM_MN10300:
1048 case EM_CYGNUS_MN10300:
1049 rtype = elf_mn10300_reloc_type (type);
1050 break;
1051
1052 case EM_MN10200:
1053 case EM_CYGNUS_MN10200:
1054 rtype = elf_mn10200_reloc_type (type);
1055 break;
1056
1057 case EM_FR30:
1058 case EM_CYGNUS_FR30:
1059 rtype = elf_fr30_reloc_type (type);
1060 break;
1061
1062 case EM_CYGNUS_FRV:
1063 rtype = elf_frv_reloc_type (type);
1064 break;
1065
1066 case EM_MCORE:
1067 rtype = elf_mcore_reloc_type (type);
1068 break;
1069
1070 case EM_MMIX:
1071 rtype = elf_mmix_reloc_type (type);
1072 break;
1073
1074 case EM_MOXIE:
1075 rtype = elf_moxie_reloc_type (type);
1076 break;
1077
1078 case EM_MSP430:
1079 case EM_MSP430_OLD:
1080 rtype = elf_msp430_reloc_type (type);
1081 break;
1082
1083 case EM_PPC:
1084 rtype = elf_ppc_reloc_type (type);
1085 break;
1086
1087 case EM_PPC64:
1088 rtype = elf_ppc64_reloc_type (type);
1089 break;
1090
1091 case EM_MIPS:
1092 case EM_MIPS_RS3_LE:
1093 rtype = elf_mips_reloc_type (type);
1094 break;
1095
1096 case EM_ALPHA:
1097 rtype = elf_alpha_reloc_type (type);
1098 break;
1099
1100 case EM_ARM:
1101 rtype = elf_arm_reloc_type (type);
1102 break;
1103
1104 case EM_ARC:
1105 rtype = elf_arc_reloc_type (type);
1106 break;
1107
1108 case EM_PARISC:
1109 rtype = elf_hppa_reloc_type (type);
1110 break;
1111
1112 case EM_H8_300:
1113 case EM_H8_300H:
1114 case EM_H8S:
1115 rtype = elf_h8_reloc_type (type);
1116 break;
1117
1118 case EM_OPENRISC:
1119 case EM_OR32:
1120 rtype = elf_or32_reloc_type (type);
1121 break;
1122
1123 case EM_PJ:
1124 case EM_PJ_OLD:
1125 rtype = elf_pj_reloc_type (type);
1126 break;
1127 case EM_IA_64:
1128 rtype = elf_ia64_reloc_type (type);
1129 break;
1130
1131 case EM_CRIS:
1132 rtype = elf_cris_reloc_type (type);
1133 break;
1134
1135 case EM_860:
1136 rtype = elf_i860_reloc_type (type);
1137 break;
1138
1139 case EM_X86_64:
1140 case EM_L1OM:
1141 rtype = elf_x86_64_reloc_type (type);
1142 break;
1143
1144 case EM_S370:
1145 rtype = i370_reloc_type (type);
1146 break;
1147
1148 case EM_S390_OLD:
1149 case EM_S390:
1150 rtype = elf_s390_reloc_type (type);
1151 break;
1152
1153 case EM_SCORE:
1154 rtype = elf_score_reloc_type (type);
1155 break;
1156
1157 case EM_XSTORMY16:
1158 rtype = elf_xstormy16_reloc_type (type);
1159 break;
1160
1161 case EM_CRX:
1162 rtype = elf_crx_reloc_type (type);
1163 break;
1164
1165 case EM_VAX:
1166 rtype = elf_vax_reloc_type (type);
1167 break;
1168
1169 case EM_IP2K:
1170 case EM_IP2K_OLD:
1171 rtype = elf_ip2k_reloc_type (type);
1172 break;
1173
1174 case EM_IQ2000:
1175 rtype = elf_iq2000_reloc_type (type);
1176 break;
1177
1178 case EM_XTENSA_OLD:
1179 case EM_XTENSA:
1180 rtype = elf_xtensa_reloc_type (type);
1181 break;
1182
1183 case EM_LATTICEMICO32:
1184 rtype = elf_lm32_reloc_type (type);
1185 break;
1186
1187 case EM_M32C_OLD:
1188 case EM_M32C:
1189 rtype = elf_m32c_reloc_type (type);
1190 break;
1191
1192 case EM_MT:
1193 rtype = elf_mt_reloc_type (type);
1194 break;
1195
1196 case EM_BLACKFIN:
1197 rtype = elf_bfin_reloc_type (type);
1198 break;
1199
1200 case EM_CYGNUS_MEP:
1201 rtype = elf_mep_reloc_type (type);
1202 break;
1203
1204 case EM_CR16:
1205 case EM_CR16_OLD:
1206 rtype = elf_cr16_reloc_type (type);
1207 break;
1208
1209 case EM_MICROBLAZE:
1210 case EM_MICROBLAZE_OLD:
1211 rtype = elf_microblaze_reloc_type (type);
1212 break;
1213
1214 case EM_RX:
1215 rtype = elf_rx_reloc_type (type);
1216 break;
1217
1218 case EM_XC16X:
1219 case EM_C166:
1220 rtype = elf_xc16x_reloc_type (type);
1221 break;
1222
1223 case EM_TI_C6000:
1224 rtype = elf_tic6x_reloc_type (type);
1225 break;
1226
1227 case EM_TILEGX:
1228 rtype = elf_tilegx_reloc_type (type);
1229 break;
1230
1231 case EM_TILEPRO:
1232 rtype = elf_tilepro_reloc_type (type);
1233 break;
1234 }
1235
1236 if (rtype == NULL)
1237 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1238 else
1239 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1240
1241 if (elf_header.e_machine == EM_ALPHA
1242 && rtype != NULL
1243 && streq (rtype, "R_ALPHA_LITUSE")
1244 && is_rela)
1245 {
1246 switch (rels[i].r_addend)
1247 {
1248 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1249 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1250 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1251 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1252 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1253 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1254 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1255 default: rtype = NULL;
1256 }
1257 if (rtype)
1258 printf (" (%s)", rtype);
1259 else
1260 {
1261 putchar (' ');
1262 printf (_("<unknown addend: %lx>"),
1263 (unsigned long) rels[i].r_addend);
1264 }
1265 }
1266 else if (symtab_index)
1267 {
1268 if (symtab == NULL || symtab_index >= nsyms)
1269 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
1270 else
1271 {
1272 Elf_Internal_Sym * psym;
1273
1274 psym = symtab + symtab_index;
1275
1276 printf (" ");
1277
1278 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1279 {
1280 const char * name;
1281 unsigned int len;
1282 unsigned int width = is_32bit_elf ? 8 : 14;
1283
1284 /* Relocations against GNU_IFUNC symbols do not use the value
1285 of the symbol as the address to relocate against. Instead
1286 they invoke the function named by the symbol and use its
1287 result as the address for relocation.
1288
1289 To indicate this to the user, do not display the value of
1290 the symbol in the "Symbols's Value" field. Instead show
1291 its name followed by () as a hint that the symbol is
1292 invoked. */
1293
1294 if (strtab == NULL
1295 || psym->st_name == 0
1296 || psym->st_name >= strtablen)
1297 name = "??";
1298 else
1299 name = strtab + psym->st_name;
1300
1301 len = print_symbol (width, name);
1302 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1303 }
1304 else
1305 {
1306 print_vma (psym->st_value, LONG_HEX);
1307
1308 printf (is_32bit_elf ? " " : " ");
1309 }
1310
1311 if (psym->st_name == 0)
1312 {
1313 const char * sec_name = "<null>";
1314 char name_buf[40];
1315
1316 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1317 {
1318 if (psym->st_shndx < elf_header.e_shnum)
1319 sec_name
1320 = SECTION_NAME (section_headers + psym->st_shndx);
1321 else if (psym->st_shndx == SHN_ABS)
1322 sec_name = "ABS";
1323 else if (psym->st_shndx == SHN_COMMON)
1324 sec_name = "COMMON";
1325 else if ((elf_header.e_machine == EM_MIPS
1326 && psym->st_shndx == SHN_MIPS_SCOMMON)
1327 || (elf_header.e_machine == EM_TI_C6000
1328 && psym->st_shndx == SHN_TIC6X_SCOMMON))
1329 sec_name = "SCOMMON";
1330 else if (elf_header.e_machine == EM_MIPS
1331 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1332 sec_name = "SUNDEF";
1333 else if ((elf_header.e_machine == EM_X86_64
1334 || elf_header.e_machine == EM_L1OM)
1335 && psym->st_shndx == SHN_X86_64_LCOMMON)
1336 sec_name = "LARGE_COMMON";
1337 else if (elf_header.e_machine == EM_IA_64
1338 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1339 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1340 sec_name = "ANSI_COM";
1341 else if (is_ia64_vms ()
1342 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1343 sec_name = "VMS_SYMVEC";
1344 else
1345 {
1346 sprintf (name_buf, "<section 0x%x>",
1347 (unsigned int) psym->st_shndx);
1348 sec_name = name_buf;
1349 }
1350 }
1351 print_symbol (22, sec_name);
1352 }
1353 else if (strtab == NULL)
1354 printf (_("<string table index: %3ld>"), psym->st_name);
1355 else if (psym->st_name >= strtablen)
1356 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
1357 else
1358 print_symbol (22, strtab + psym->st_name);
1359
1360 if (is_rela)
1361 {
1362 bfd_signed_vma off = rels[i].r_addend;
1363
1364 if (off < 0)
1365 printf (" - %" BFD_VMA_FMT "x", - off);
1366 else
1367 printf (" + %" BFD_VMA_FMT "x", off);
1368 }
1369 }
1370 }
1371 else if (is_rela)
1372 {
1373 printf ("%*c", is_32bit_elf ?
1374 (do_wide ? 34 : 28) : (do_wide ? 26 : 20), ' ');
1375 print_vma (rels[i].r_addend, LONG_HEX);
1376 }
1377
1378 if (elf_header.e_machine == EM_SPARCV9
1379 && rtype != NULL
1380 && streq (rtype, "R_SPARC_OLO10"))
1381 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1382
1383 putchar ('\n');
1384
1385 #ifdef BFD64
1386 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1387 {
1388 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1389 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1390 const char * rtype2 = elf_mips_reloc_type (type2);
1391 const char * rtype3 = elf_mips_reloc_type (type3);
1392
1393 printf (" Type2: ");
1394
1395 if (rtype2 == NULL)
1396 printf (_("unrecognized: %-7lx"),
1397 (unsigned long) type2 & 0xffffffff);
1398 else
1399 printf ("%-17.17s", rtype2);
1400
1401 printf ("\n Type3: ");
1402
1403 if (rtype3 == NULL)
1404 printf (_("unrecognized: %-7lx"),
1405 (unsigned long) type3 & 0xffffffff);
1406 else
1407 printf ("%-17.17s", rtype3);
1408
1409 putchar ('\n');
1410 }
1411 #endif /* BFD64 */
1412 }
1413
1414 free (rels);
1415 }
1416
1417 static const char *
1418 get_mips_dynamic_type (unsigned long type)
1419 {
1420 switch (type)
1421 {
1422 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1423 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1424 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1425 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1426 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1427 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1428 case DT_MIPS_MSYM: return "MIPS_MSYM";
1429 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1430 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1431 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1432 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1433 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1434 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1435 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1436 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1437 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1438 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1439 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1440 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1441 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1442 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1443 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1444 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1445 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1446 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1447 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1448 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1449 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1450 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1451 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1452 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1453 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1454 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1455 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1456 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1457 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1458 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1459 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1460 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1461 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1462 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1463 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1464 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1465 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1466 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1467 default:
1468 return NULL;
1469 }
1470 }
1471
1472 static const char *
1473 get_sparc64_dynamic_type (unsigned long type)
1474 {
1475 switch (type)
1476 {
1477 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1478 default:
1479 return NULL;
1480 }
1481 }
1482
1483 static const char *
1484 get_ppc_dynamic_type (unsigned long type)
1485 {
1486 switch (type)
1487 {
1488 case DT_PPC_GOT: return "PPC_GOT";
1489 case DT_PPC_TLSOPT: return "PPC_TLSOPT";
1490 default:
1491 return NULL;
1492 }
1493 }
1494
1495 static const char *
1496 get_ppc64_dynamic_type (unsigned long type)
1497 {
1498 switch (type)
1499 {
1500 case DT_PPC64_GLINK: return "PPC64_GLINK";
1501 case DT_PPC64_OPD: return "PPC64_OPD";
1502 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1503 case DT_PPC64_TLSOPT: return "PPC64_TLSOPT";
1504 default:
1505 return NULL;
1506 }
1507 }
1508
1509 static const char *
1510 get_parisc_dynamic_type (unsigned long type)
1511 {
1512 switch (type)
1513 {
1514 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1515 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1516 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1517 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1518 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1519 case DT_HP_PREINIT: return "HP_PREINIT";
1520 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1521 case DT_HP_NEEDED: return "HP_NEEDED";
1522 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1523 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1524 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1525 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1526 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1527 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1528 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1529 case DT_HP_FILTERED: return "HP_FILTERED";
1530 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1531 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1532 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1533 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1534 case DT_PLT: return "PLT";
1535 case DT_PLT_SIZE: return "PLT_SIZE";
1536 case DT_DLT: return "DLT";
1537 case DT_DLT_SIZE: return "DLT_SIZE";
1538 default:
1539 return NULL;
1540 }
1541 }
1542
1543 static const char *
1544 get_ia64_dynamic_type (unsigned long type)
1545 {
1546 switch (type)
1547 {
1548 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1549 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1550 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1551 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1552 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1553 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1554 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1555 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1556 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1557 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1558 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1559 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1560 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1561 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1562 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1563 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1564 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1565 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1566 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1567 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1568 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1569 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1570 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1571 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1572 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1573 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1574 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1575 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1576 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1577 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1578 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
1579 default:
1580 return NULL;
1581 }
1582 }
1583
1584 static const char *
1585 get_alpha_dynamic_type (unsigned long type)
1586 {
1587 switch (type)
1588 {
1589 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1590 default:
1591 return NULL;
1592 }
1593 }
1594
1595 static const char *
1596 get_score_dynamic_type (unsigned long type)
1597 {
1598 switch (type)
1599 {
1600 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1601 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1602 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1603 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1604 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1605 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1606 default:
1607 return NULL;
1608 }
1609 }
1610
1611 static const char *
1612 get_tic6x_dynamic_type (unsigned long type)
1613 {
1614 switch (type)
1615 {
1616 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1617 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1618 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1619 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1620 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1621 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1622 default:
1623 return NULL;
1624 }
1625 }
1626
1627 static const char *
1628 get_dynamic_type (unsigned long type)
1629 {
1630 static char buff[64];
1631
1632 switch (type)
1633 {
1634 case DT_NULL: return "NULL";
1635 case DT_NEEDED: return "NEEDED";
1636 case DT_PLTRELSZ: return "PLTRELSZ";
1637 case DT_PLTGOT: return "PLTGOT";
1638 case DT_HASH: return "HASH";
1639 case DT_STRTAB: return "STRTAB";
1640 case DT_SYMTAB: return "SYMTAB";
1641 case DT_RELA: return "RELA";
1642 case DT_RELASZ: return "RELASZ";
1643 case DT_RELAENT: return "RELAENT";
1644 case DT_STRSZ: return "STRSZ";
1645 case DT_SYMENT: return "SYMENT";
1646 case DT_INIT: return "INIT";
1647 case DT_FINI: return "FINI";
1648 case DT_SONAME: return "SONAME";
1649 case DT_RPATH: return "RPATH";
1650 case DT_SYMBOLIC: return "SYMBOLIC";
1651 case DT_REL: return "REL";
1652 case DT_RELSZ: return "RELSZ";
1653 case DT_RELENT: return "RELENT";
1654 case DT_PLTREL: return "PLTREL";
1655 case DT_DEBUG: return "DEBUG";
1656 case DT_TEXTREL: return "TEXTREL";
1657 case DT_JMPREL: return "JMPREL";
1658 case DT_BIND_NOW: return "BIND_NOW";
1659 case DT_INIT_ARRAY: return "INIT_ARRAY";
1660 case DT_FINI_ARRAY: return "FINI_ARRAY";
1661 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1662 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1663 case DT_RUNPATH: return "RUNPATH";
1664 case DT_FLAGS: return "FLAGS";
1665
1666 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1667 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1668
1669 case DT_CHECKSUM: return "CHECKSUM";
1670 case DT_PLTPADSZ: return "PLTPADSZ";
1671 case DT_MOVEENT: return "MOVEENT";
1672 case DT_MOVESZ: return "MOVESZ";
1673 case DT_FEATURE: return "FEATURE";
1674 case DT_POSFLAG_1: return "POSFLAG_1";
1675 case DT_SYMINSZ: return "SYMINSZ";
1676 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
1677
1678 case DT_ADDRRNGLO: return "ADDRRNGLO";
1679 case DT_CONFIG: return "CONFIG";
1680 case DT_DEPAUDIT: return "DEPAUDIT";
1681 case DT_AUDIT: return "AUDIT";
1682 case DT_PLTPAD: return "PLTPAD";
1683 case DT_MOVETAB: return "MOVETAB";
1684 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
1685
1686 case DT_VERSYM: return "VERSYM";
1687
1688 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1689 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
1690 case DT_RELACOUNT: return "RELACOUNT";
1691 case DT_RELCOUNT: return "RELCOUNT";
1692 case DT_FLAGS_1: return "FLAGS_1";
1693 case DT_VERDEF: return "VERDEF";
1694 case DT_VERDEFNUM: return "VERDEFNUM";
1695 case DT_VERNEED: return "VERNEED";
1696 case DT_VERNEEDNUM: return "VERNEEDNUM";
1697
1698 case DT_AUXILIARY: return "AUXILIARY";
1699 case DT_USED: return "USED";
1700 case DT_FILTER: return "FILTER";
1701
1702 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1703 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1704 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1705 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1706 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1707 case DT_GNU_HASH: return "GNU_HASH";
1708
1709 default:
1710 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1711 {
1712 const char * result;
1713
1714 switch (elf_header.e_machine)
1715 {
1716 case EM_MIPS:
1717 case EM_MIPS_RS3_LE:
1718 result = get_mips_dynamic_type (type);
1719 break;
1720 case EM_SPARCV9:
1721 result = get_sparc64_dynamic_type (type);
1722 break;
1723 case EM_PPC:
1724 result = get_ppc_dynamic_type (type);
1725 break;
1726 case EM_PPC64:
1727 result = get_ppc64_dynamic_type (type);
1728 break;
1729 case EM_IA_64:
1730 result = get_ia64_dynamic_type (type);
1731 break;
1732 case EM_ALPHA:
1733 result = get_alpha_dynamic_type (type);
1734 break;
1735 case EM_SCORE:
1736 result = get_score_dynamic_type (type);
1737 break;
1738 case EM_TI_C6000:
1739 result = get_tic6x_dynamic_type (type);
1740 break;
1741 default:
1742 result = NULL;
1743 break;
1744 }
1745
1746 if (result != NULL)
1747 return result;
1748
1749 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
1750 }
1751 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1752 || (elf_header.e_machine == EM_PARISC
1753 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
1754 {
1755 const char * result;
1756
1757 switch (elf_header.e_machine)
1758 {
1759 case EM_PARISC:
1760 result = get_parisc_dynamic_type (type);
1761 break;
1762 case EM_IA_64:
1763 result = get_ia64_dynamic_type (type);
1764 break;
1765 default:
1766 result = NULL;
1767 break;
1768 }
1769
1770 if (result != NULL)
1771 return result;
1772
1773 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1774 type);
1775 }
1776 else
1777 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
1778
1779 return buff;
1780 }
1781 }
1782
1783 static char *
1784 get_file_type (unsigned e_type)
1785 {
1786 static char buff[32];
1787
1788 switch (e_type)
1789 {
1790 case ET_NONE: return _("NONE (None)");
1791 case ET_REL: return _("REL (Relocatable file)");
1792 case ET_EXEC: return _("EXEC (Executable file)");
1793 case ET_DYN: return _("DYN (Shared object file)");
1794 case ET_CORE: return _("CORE (Core file)");
1795
1796 default:
1797 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1798 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
1799 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1800 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
1801 else
1802 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
1803 return buff;
1804 }
1805 }
1806
1807 static char *
1808 get_machine_name (unsigned e_machine)
1809 {
1810 static char buff[64]; /* XXX */
1811
1812 switch (e_machine)
1813 {
1814 case EM_NONE: return _("None");
1815 case EM_M32: return "WE32100";
1816 case EM_SPARC: return "Sparc";
1817 case EM_SPU: return "SPU";
1818 case EM_386: return "Intel 80386";
1819 case EM_68K: return "MC68000";
1820 case EM_88K: return "MC88000";
1821 case EM_486: return "Intel 80486";
1822 case EM_860: return "Intel 80860";
1823 case EM_MIPS: return "MIPS R3000";
1824 case EM_S370: return "IBM System/370";
1825 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
1826 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
1827 case EM_PARISC: return "HPPA";
1828 case EM_PPC_OLD: return "Power PC (old)";
1829 case EM_SPARC32PLUS: return "Sparc v8+" ;
1830 case EM_960: return "Intel 90860";
1831 case EM_PPC: return "PowerPC";
1832 case EM_PPC64: return "PowerPC64";
1833 case EM_V800: return "NEC V800";
1834 case EM_FR20: return "Fujitsu FR20";
1835 case EM_RH32: return "TRW RH32";
1836 case EM_MCORE: return "MCORE";
1837 case EM_ARM: return "ARM";
1838 case EM_OLD_ALPHA: return "Digital Alpha (old)";
1839 case EM_SH: return "Renesas / SuperH SH";
1840 case EM_SPARCV9: return "Sparc v9";
1841 case EM_TRICORE: return "Siemens Tricore";
1842 case EM_ARC: return "ARC";
1843 case EM_H8_300: return "Renesas H8/300";
1844 case EM_H8_300H: return "Renesas H8/300H";
1845 case EM_H8S: return "Renesas H8S";
1846 case EM_H8_500: return "Renesas H8/500";
1847 case EM_IA_64: return "Intel IA-64";
1848 case EM_MIPS_X: return "Stanford MIPS-X";
1849 case EM_COLDFIRE: return "Motorola Coldfire";
1850 case EM_68HC12: return "Motorola M68HC12";
1851 case EM_ALPHA: return "Alpha";
1852 case EM_CYGNUS_D10V:
1853 case EM_D10V: return "d10v";
1854 case EM_CYGNUS_D30V:
1855 case EM_D30V: return "d30v";
1856 case EM_CYGNUS_M32R:
1857 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
1858 case EM_CYGNUS_V850:
1859 case EM_V850: return "Renesas v850";
1860 case EM_CYGNUS_MN10300:
1861 case EM_MN10300: return "mn10300";
1862 case EM_CYGNUS_MN10200:
1863 case EM_MN10200: return "mn10200";
1864 case EM_MOXIE: return "Moxie";
1865 case EM_CYGNUS_FR30:
1866 case EM_FR30: return "Fujitsu FR30";
1867 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
1868 case EM_PJ_OLD:
1869 case EM_PJ: return "picoJava";
1870 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1871 case EM_PCP: return "Siemens PCP";
1872 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1873 case EM_NDR1: return "Denso NDR1 microprocesspr";
1874 case EM_STARCORE: return "Motorola Star*Core processor";
1875 case EM_ME16: return "Toyota ME16 processor";
1876 case EM_ST100: return "STMicroelectronics ST100 processor";
1877 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
1878 case EM_PDSP: return "Sony DSP processor";
1879 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
1880 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
1881 case EM_FX66: return "Siemens FX66 microcontroller";
1882 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1883 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1884 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
1885 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1886 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1887 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1888 case EM_SVX: return "Silicon Graphics SVx";
1889 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1890 case EM_VAX: return "Digital VAX";
1891 case EM_AVR_OLD:
1892 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1893 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
1894 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
1895 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
1896 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
1897 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
1898 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
1899 case EM_PRISM: return "Vitesse Prism";
1900 case EM_X86_64: return "Advanced Micro Devices X86-64";
1901 case EM_L1OM: return "Intel L1OM";
1902 case EM_S390_OLD:
1903 case EM_S390: return "IBM S/390";
1904 case EM_SCORE: return "SUNPLUS S+Core";
1905 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
1906 case EM_OPENRISC:
1907 case EM_OR32: return "OpenRISC";
1908 case EM_ARC_A5: return "ARC International ARCompact processor";
1909 case EM_CRX: return "National Semiconductor CRX microprocessor";
1910 case EM_DLX: return "OpenDLX";
1911 case EM_IP2K_OLD:
1912 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
1913 case EM_IQ2000: return "Vitesse IQ2000";
1914 case EM_XTENSA_OLD:
1915 case EM_XTENSA: return "Tensilica Xtensa Processor";
1916 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
1917 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
1918 case EM_NS32K: return "National Semiconductor 32000 series";
1919 case EM_TPC: return "Tenor Network TPC processor";
1920 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
1921 case EM_MAX: return "MAX Processor";
1922 case EM_CR: return "National Semiconductor CompactRISC";
1923 case EM_F2MC16: return "Fujitsu F2MC16";
1924 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
1925 case EM_LATTICEMICO32: return "Lattice Mico32";
1926 case EM_M32C_OLD:
1927 case EM_M32C: return "Renesas M32c";
1928 case EM_MT: return "Morpho Techologies MT processor";
1929 case EM_BLACKFIN: return "Analog Devices Blackfin";
1930 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
1931 case EM_SEP: return "Sharp embedded microprocessor";
1932 case EM_ARCA: return "Arca RISC microprocessor";
1933 case EM_UNICORE: return "Unicore";
1934 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
1935 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
1936 case EM_NIOS32: return "Altera Nios";
1937 case EM_ALTERA_NIOS2: return "Altera Nios II";
1938 case EM_C166:
1939 case EM_XC16X: return "Infineon Technologies xc16x";
1940 case EM_M16C: return "Renesas M16C series microprocessors";
1941 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
1942 case EM_CE: return "Freescale Communication Engine RISC core";
1943 case EM_TSK3000: return "Altium TSK3000 core";
1944 case EM_RS08: return "Freescale RS08 embedded processor";
1945 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
1946 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
1947 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
1948 case EM_SE_C17: return "Seiko Epson C17 family";
1949 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
1950 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
1951 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
1952 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
1953 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
1954 case EM_R32C: return "Renesas R32C series microprocessors";
1955 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
1956 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
1957 case EM_8051: return "Intel 8051 and variants";
1958 case EM_STXP7X: return "STMicroelectronics STxP7x family";
1959 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
1960 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
1961 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
1962 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
1963 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
1964 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
1965 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
1966 case EM_CR16:
1967 case EM_CR16_OLD: return "National Semiconductor's CR16";
1968 case EM_MICROBLAZE: return "Xilinx MicroBlaze";
1969 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
1970 case EM_RX: return "Renesas RX";
1971 case EM_METAG: return "Imagination Technologies META processor architecture";
1972 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
1973 case EM_ECOG16: return "Cyan Technology eCOG16 family";
1974 case EM_ETPU: return "Freescale Extended Time Processing Unit";
1975 case EM_SLE9X: return "Infineon Technologies SLE9X core";
1976 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
1977 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
1978 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
1979 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
1980 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
1981 case EM_CUDA: return "NVIDIA CUDA architecture";
1982 default:
1983 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
1984 return buff;
1985 }
1986 }
1987
1988 static void
1989 decode_ARM_machine_flags (unsigned e_flags, char buf[])
1990 {
1991 unsigned eabi;
1992 int unknown = 0;
1993
1994 eabi = EF_ARM_EABI_VERSION (e_flags);
1995 e_flags &= ~ EF_ARM_EABIMASK;
1996
1997 /* Handle "generic" ARM flags. */
1998 if (e_flags & EF_ARM_RELEXEC)
1999 {
2000 strcat (buf, ", relocatable executable");
2001 e_flags &= ~ EF_ARM_RELEXEC;
2002 }
2003
2004 if (e_flags & EF_ARM_HASENTRY)
2005 {
2006 strcat (buf, ", has entry point");
2007 e_flags &= ~ EF_ARM_HASENTRY;
2008 }
2009
2010 /* Now handle EABI specific flags. */
2011 switch (eabi)
2012 {
2013 default:
2014 strcat (buf, ", <unrecognized EABI>");
2015 if (e_flags)
2016 unknown = 1;
2017 break;
2018
2019 case EF_ARM_EABI_VER1:
2020 strcat (buf, ", Version1 EABI");
2021 while (e_flags)
2022 {
2023 unsigned flag;
2024
2025 /* Process flags one bit at a time. */
2026 flag = e_flags & - e_flags;
2027 e_flags &= ~ flag;
2028
2029 switch (flag)
2030 {
2031 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2032 strcat (buf, ", sorted symbol tables");
2033 break;
2034
2035 default:
2036 unknown = 1;
2037 break;
2038 }
2039 }
2040 break;
2041
2042 case EF_ARM_EABI_VER2:
2043 strcat (buf, ", Version2 EABI");
2044 while (e_flags)
2045 {
2046 unsigned flag;
2047
2048 /* Process flags one bit at a time. */
2049 flag = e_flags & - e_flags;
2050 e_flags &= ~ flag;
2051
2052 switch (flag)
2053 {
2054 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2055 strcat (buf, ", sorted symbol tables");
2056 break;
2057
2058 case EF_ARM_DYNSYMSUSESEGIDX:
2059 strcat (buf, ", dynamic symbols use segment index");
2060 break;
2061
2062 case EF_ARM_MAPSYMSFIRST:
2063 strcat (buf, ", mapping symbols precede others");
2064 break;
2065
2066 default:
2067 unknown = 1;
2068 break;
2069 }
2070 }
2071 break;
2072
2073 case EF_ARM_EABI_VER3:
2074 strcat (buf, ", Version3 EABI");
2075 break;
2076
2077 case EF_ARM_EABI_VER4:
2078 strcat (buf, ", Version4 EABI");
2079 goto eabi;
2080
2081 case EF_ARM_EABI_VER5:
2082 strcat (buf, ", Version5 EABI");
2083 eabi:
2084 while (e_flags)
2085 {
2086 unsigned flag;
2087
2088 /* Process flags one bit at a time. */
2089 flag = e_flags & - e_flags;
2090 e_flags &= ~ flag;
2091
2092 switch (flag)
2093 {
2094 case EF_ARM_BE8:
2095 strcat (buf, ", BE8");
2096 break;
2097
2098 case EF_ARM_LE8:
2099 strcat (buf, ", LE8");
2100 break;
2101
2102 default:
2103 unknown = 1;
2104 break;
2105 }
2106 }
2107 break;
2108
2109 case EF_ARM_EABI_UNKNOWN:
2110 strcat (buf, ", GNU EABI");
2111 while (e_flags)
2112 {
2113 unsigned flag;
2114
2115 /* Process flags one bit at a time. */
2116 flag = e_flags & - e_flags;
2117 e_flags &= ~ flag;
2118
2119 switch (flag)
2120 {
2121 case EF_ARM_INTERWORK:
2122 strcat (buf, ", interworking enabled");
2123 break;
2124
2125 case EF_ARM_APCS_26:
2126 strcat (buf, ", uses APCS/26");
2127 break;
2128
2129 case EF_ARM_APCS_FLOAT:
2130 strcat (buf, ", uses APCS/float");
2131 break;
2132
2133 case EF_ARM_PIC:
2134 strcat (buf, ", position independent");
2135 break;
2136
2137 case EF_ARM_ALIGN8:
2138 strcat (buf, ", 8 bit structure alignment");
2139 break;
2140
2141 case EF_ARM_NEW_ABI:
2142 strcat (buf, ", uses new ABI");
2143 break;
2144
2145 case EF_ARM_OLD_ABI:
2146 strcat (buf, ", uses old ABI");
2147 break;
2148
2149 case EF_ARM_SOFT_FLOAT:
2150 strcat (buf, ", software FP");
2151 break;
2152
2153 case EF_ARM_VFP_FLOAT:
2154 strcat (buf, ", VFP");
2155 break;
2156
2157 case EF_ARM_MAVERICK_FLOAT:
2158 strcat (buf, ", Maverick FP");
2159 break;
2160
2161 default:
2162 unknown = 1;
2163 break;
2164 }
2165 }
2166 }
2167
2168 if (unknown)
2169 strcat (buf,_(", <unknown>"));
2170 }
2171
2172 static char *
2173 get_machine_flags (unsigned e_flags, unsigned e_machine)
2174 {
2175 static char buf[1024];
2176
2177 buf[0] = '\0';
2178
2179 if (e_flags)
2180 {
2181 switch (e_machine)
2182 {
2183 default:
2184 break;
2185
2186 case EM_ARM:
2187 decode_ARM_machine_flags (e_flags, buf);
2188 break;
2189
2190 case EM_BLACKFIN:
2191 if (e_flags & EF_BFIN_PIC)
2192 strcat (buf, ", PIC");
2193
2194 if (e_flags & EF_BFIN_FDPIC)
2195 strcat (buf, ", FDPIC");
2196
2197 if (e_flags & EF_BFIN_CODE_IN_L1)
2198 strcat (buf, ", code in L1");
2199
2200 if (e_flags & EF_BFIN_DATA_IN_L1)
2201 strcat (buf, ", data in L1");
2202
2203 break;
2204
2205 case EM_CYGNUS_FRV:
2206 switch (e_flags & EF_FRV_CPU_MASK)
2207 {
2208 case EF_FRV_CPU_GENERIC:
2209 break;
2210
2211 default:
2212 strcat (buf, ", fr???");
2213 break;
2214
2215 case EF_FRV_CPU_FR300:
2216 strcat (buf, ", fr300");
2217 break;
2218
2219 case EF_FRV_CPU_FR400:
2220 strcat (buf, ", fr400");
2221 break;
2222 case EF_FRV_CPU_FR405:
2223 strcat (buf, ", fr405");
2224 break;
2225
2226 case EF_FRV_CPU_FR450:
2227 strcat (buf, ", fr450");
2228 break;
2229
2230 case EF_FRV_CPU_FR500:
2231 strcat (buf, ", fr500");
2232 break;
2233 case EF_FRV_CPU_FR550:
2234 strcat (buf, ", fr550");
2235 break;
2236
2237 case EF_FRV_CPU_SIMPLE:
2238 strcat (buf, ", simple");
2239 break;
2240 case EF_FRV_CPU_TOMCAT:
2241 strcat (buf, ", tomcat");
2242 break;
2243 }
2244 break;
2245
2246 case EM_68K:
2247 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
2248 strcat (buf, ", m68000");
2249 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
2250 strcat (buf, ", cpu32");
2251 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2252 strcat (buf, ", fido_a");
2253 else
2254 {
2255 char const * isa = _("unknown");
2256 char const * mac = _("unknown mac");
2257 char const * additional = NULL;
2258
2259 switch (e_flags & EF_M68K_CF_ISA_MASK)
2260 {
2261 case EF_M68K_CF_ISA_A_NODIV:
2262 isa = "A";
2263 additional = ", nodiv";
2264 break;
2265 case EF_M68K_CF_ISA_A:
2266 isa = "A";
2267 break;
2268 case EF_M68K_CF_ISA_A_PLUS:
2269 isa = "A+";
2270 break;
2271 case EF_M68K_CF_ISA_B_NOUSP:
2272 isa = "B";
2273 additional = ", nousp";
2274 break;
2275 case EF_M68K_CF_ISA_B:
2276 isa = "B";
2277 break;
2278 case EF_M68K_CF_ISA_C:
2279 isa = "C";
2280 break;
2281 case EF_M68K_CF_ISA_C_NODIV:
2282 isa = "C";
2283 additional = ", nodiv";
2284 break;
2285 }
2286 strcat (buf, ", cf, isa ");
2287 strcat (buf, isa);
2288 if (additional)
2289 strcat (buf, additional);
2290 if (e_flags & EF_M68K_CF_FLOAT)
2291 strcat (buf, ", float");
2292 switch (e_flags & EF_M68K_CF_MAC_MASK)
2293 {
2294 case 0:
2295 mac = NULL;
2296 break;
2297 case EF_M68K_CF_MAC:
2298 mac = "mac";
2299 break;
2300 case EF_M68K_CF_EMAC:
2301 mac = "emac";
2302 break;
2303 case EF_M68K_CF_EMAC_B:
2304 mac = "emac_b";
2305 break;
2306 }
2307 if (mac)
2308 {
2309 strcat (buf, ", ");
2310 strcat (buf, mac);
2311 }
2312 }
2313 break;
2314
2315 case EM_PPC:
2316 if (e_flags & EF_PPC_EMB)
2317 strcat (buf, ", emb");
2318
2319 if (e_flags & EF_PPC_RELOCATABLE)
2320 strcat (buf, _(", relocatable"));
2321
2322 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2323 strcat (buf, _(", relocatable-lib"));
2324 break;
2325
2326 case EM_V850:
2327 case EM_CYGNUS_V850:
2328 switch (e_flags & EF_V850_ARCH)
2329 {
2330 case E_V850E2V3_ARCH:
2331 strcat (buf, ", v850e2v3");
2332 break;
2333 case E_V850E2_ARCH:
2334 strcat (buf, ", v850e2");
2335 break;
2336 case E_V850E1_ARCH:
2337 strcat (buf, ", v850e1");
2338 break;
2339 case E_V850E_ARCH:
2340 strcat (buf, ", v850e");
2341 break;
2342 case E_V850_ARCH:
2343 strcat (buf, ", v850");
2344 break;
2345 default:
2346 strcat (buf, _(", unknown v850 architecture variant"));
2347 break;
2348 }
2349 break;
2350
2351 case EM_M32R:
2352 case EM_CYGNUS_M32R:
2353 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2354 strcat (buf, ", m32r");
2355 break;
2356
2357 case EM_MIPS:
2358 case EM_MIPS_RS3_LE:
2359 if (e_flags & EF_MIPS_NOREORDER)
2360 strcat (buf, ", noreorder");
2361
2362 if (e_flags & EF_MIPS_PIC)
2363 strcat (buf, ", pic");
2364
2365 if (e_flags & EF_MIPS_CPIC)
2366 strcat (buf, ", cpic");
2367
2368 if (e_flags & EF_MIPS_UCODE)
2369 strcat (buf, ", ugen_reserved");
2370
2371 if (e_flags & EF_MIPS_ABI2)
2372 strcat (buf, ", abi2");
2373
2374 if (e_flags & EF_MIPS_OPTIONS_FIRST)
2375 strcat (buf, ", odk first");
2376
2377 if (e_flags & EF_MIPS_32BITMODE)
2378 strcat (buf, ", 32bitmode");
2379
2380 switch ((e_flags & EF_MIPS_MACH))
2381 {
2382 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2383 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2384 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
2385 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
2386 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2387 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2388 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2389 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
2390 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
2391 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
2392 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2393 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
2394 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
2395 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
2396 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
2397 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
2398 case 0:
2399 /* We simply ignore the field in this case to avoid confusion:
2400 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2401 extension. */
2402 break;
2403 default: strcat (buf, _(", unknown CPU")); break;
2404 }
2405
2406 switch ((e_flags & EF_MIPS_ABI))
2407 {
2408 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2409 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2410 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2411 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2412 case 0:
2413 /* We simply ignore the field in this case to avoid confusion:
2414 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2415 This means it is likely to be an o32 file, but not for
2416 sure. */
2417 break;
2418 default: strcat (buf, _(", unknown ABI")); break;
2419 }
2420
2421 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2422 strcat (buf, ", mdmx");
2423
2424 if (e_flags & EF_MIPS_ARCH_ASE_M16)
2425 strcat (buf, ", mips16");
2426
2427 switch ((e_flags & EF_MIPS_ARCH))
2428 {
2429 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2430 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2431 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2432 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2433 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2434 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
2435 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
2436 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
2437 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2438 default: strcat (buf, _(", unknown ISA")); break;
2439 }
2440
2441 if (e_flags & EF_SH_PIC)
2442 strcat (buf, ", pic");
2443
2444 if (e_flags & EF_SH_FDPIC)
2445 strcat (buf, ", fdpic");
2446 break;
2447
2448 case EM_SH:
2449 switch ((e_flags & EF_SH_MACH_MASK))
2450 {
2451 case EF_SH1: strcat (buf, ", sh1"); break;
2452 case EF_SH2: strcat (buf, ", sh2"); break;
2453 case EF_SH3: strcat (buf, ", sh3"); break;
2454 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2455 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2456 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2457 case EF_SH3E: strcat (buf, ", sh3e"); break;
2458 case EF_SH4: strcat (buf, ", sh4"); break;
2459 case EF_SH5: strcat (buf, ", sh5"); break;
2460 case EF_SH2E: strcat (buf, ", sh2e"); break;
2461 case EF_SH4A: strcat (buf, ", sh4a"); break;
2462 case EF_SH2A: strcat (buf, ", sh2a"); break;
2463 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2464 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
2465 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
2466 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2467 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2468 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2469 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2470 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2471 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2472 default: strcat (buf, _(", unknown ISA")); break;
2473 }
2474
2475 break;
2476
2477 case EM_SPARCV9:
2478 if (e_flags & EF_SPARC_32PLUS)
2479 strcat (buf, ", v8+");
2480
2481 if (e_flags & EF_SPARC_SUN_US1)
2482 strcat (buf, ", ultrasparcI");
2483
2484 if (e_flags & EF_SPARC_SUN_US3)
2485 strcat (buf, ", ultrasparcIII");
2486
2487 if (e_flags & EF_SPARC_HAL_R1)
2488 strcat (buf, ", halr1");
2489
2490 if (e_flags & EF_SPARC_LEDATA)
2491 strcat (buf, ", ledata");
2492
2493 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2494 strcat (buf, ", tso");
2495
2496 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2497 strcat (buf, ", pso");
2498
2499 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2500 strcat (buf, ", rmo");
2501 break;
2502
2503 case EM_PARISC:
2504 switch (e_flags & EF_PARISC_ARCH)
2505 {
2506 case EFA_PARISC_1_0:
2507 strcpy (buf, ", PA-RISC 1.0");
2508 break;
2509 case EFA_PARISC_1_1:
2510 strcpy (buf, ", PA-RISC 1.1");
2511 break;
2512 case EFA_PARISC_2_0:
2513 strcpy (buf, ", PA-RISC 2.0");
2514 break;
2515 default:
2516 break;
2517 }
2518 if (e_flags & EF_PARISC_TRAPNIL)
2519 strcat (buf, ", trapnil");
2520 if (e_flags & EF_PARISC_EXT)
2521 strcat (buf, ", ext");
2522 if (e_flags & EF_PARISC_LSB)
2523 strcat (buf, ", lsb");
2524 if (e_flags & EF_PARISC_WIDE)
2525 strcat (buf, ", wide");
2526 if (e_flags & EF_PARISC_NO_KABP)
2527 strcat (buf, ", no kabp");
2528 if (e_flags & EF_PARISC_LAZYSWAP)
2529 strcat (buf, ", lazyswap");
2530 break;
2531
2532 case EM_PJ:
2533 case EM_PJ_OLD:
2534 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2535 strcat (buf, ", new calling convention");
2536
2537 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2538 strcat (buf, ", gnu calling convention");
2539 break;
2540
2541 case EM_IA_64:
2542 if ((e_flags & EF_IA_64_ABI64))
2543 strcat (buf, ", 64-bit");
2544 else
2545 strcat (buf, ", 32-bit");
2546 if ((e_flags & EF_IA_64_REDUCEDFP))
2547 strcat (buf, ", reduced fp model");
2548 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2549 strcat (buf, ", no function descriptors, constant gp");
2550 else if ((e_flags & EF_IA_64_CONS_GP))
2551 strcat (buf, ", constant gp");
2552 if ((e_flags & EF_IA_64_ABSOLUTE))
2553 strcat (buf, ", absolute");
2554 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
2555 {
2556 if ((e_flags & EF_IA_64_VMS_LINKAGES))
2557 strcat (buf, ", vms_linkages");
2558 switch ((e_flags & EF_IA_64_VMS_COMCOD))
2559 {
2560 case EF_IA_64_VMS_COMCOD_SUCCESS:
2561 break;
2562 case EF_IA_64_VMS_COMCOD_WARNING:
2563 strcat (buf, ", warning");
2564 break;
2565 case EF_IA_64_VMS_COMCOD_ERROR:
2566 strcat (buf, ", error");
2567 break;
2568 case EF_IA_64_VMS_COMCOD_ABORT:
2569 strcat (buf, ", abort");
2570 break;
2571 default:
2572 abort ();
2573 }
2574 }
2575 break;
2576
2577 case EM_VAX:
2578 if ((e_flags & EF_VAX_NONPIC))
2579 strcat (buf, ", non-PIC");
2580 if ((e_flags & EF_VAX_DFLOAT))
2581 strcat (buf, ", D-Float");
2582 if ((e_flags & EF_VAX_GFLOAT))
2583 strcat (buf, ", G-Float");
2584 break;
2585
2586 case EM_RX:
2587 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
2588 strcat (buf, ", 64-bit doubles");
2589 if (e_flags & E_FLAG_RX_DSP)
2590 strcat (buf, ", dsp");
2591
2592 case EM_S390:
2593 if (e_flags & EF_S390_HIGH_GPRS)
2594 strcat (buf, ", highgprs");
2595
2596 case EM_TI_C6000:
2597 if ((e_flags & EF_C6000_REL))
2598 strcat (buf, ", relocatable module");
2599 }
2600 }
2601
2602 return buf;
2603 }
2604
2605 static const char *
2606 get_osabi_name (unsigned int osabi)
2607 {
2608 static char buff[32];
2609
2610 switch (osabi)
2611 {
2612 case ELFOSABI_NONE: return "UNIX - System V";
2613 case ELFOSABI_HPUX: return "UNIX - HP-UX";
2614 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
2615 case ELFOSABI_LINUX: return "UNIX - Linux";
2616 case ELFOSABI_HURD: return "GNU/Hurd";
2617 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
2618 case ELFOSABI_AIX: return "UNIX - AIX";
2619 case ELFOSABI_IRIX: return "UNIX - IRIX";
2620 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
2621 case ELFOSABI_TRU64: return "UNIX - TRU64";
2622 case ELFOSABI_MODESTO: return "Novell - Modesto";
2623 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
2624 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
2625 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
2626 case ELFOSABI_AROS: return "AROS";
2627 case ELFOSABI_FENIXOS: return "FenixOS";
2628 default:
2629 if (osabi >= 64)
2630 switch (elf_header.e_machine)
2631 {
2632 case EM_ARM:
2633 switch (osabi)
2634 {
2635 case ELFOSABI_ARM: return "ARM";
2636 default:
2637 break;
2638 }
2639 break;
2640
2641 case EM_MSP430:
2642 case EM_MSP430_OLD:
2643 switch (osabi)
2644 {
2645 case ELFOSABI_STANDALONE: return _("Standalone App");
2646 default:
2647 break;
2648 }
2649 break;
2650
2651 case EM_TI_C6000:
2652 switch (osabi)
2653 {
2654 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
2655 case ELFOSABI_C6000_LINUX: return "Linux C6000";
2656 default:
2657 break;
2658 }
2659 break;
2660
2661 default:
2662 break;
2663 }
2664 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
2665 return buff;
2666 }
2667 }
2668
2669 static const char *
2670 get_arm_segment_type (unsigned long type)
2671 {
2672 switch (type)
2673 {
2674 case PT_ARM_EXIDX:
2675 return "EXIDX";
2676 default:
2677 break;
2678 }
2679
2680 return NULL;
2681 }
2682
2683 static const char *
2684 get_mips_segment_type (unsigned long type)
2685 {
2686 switch (type)
2687 {
2688 case PT_MIPS_REGINFO:
2689 return "REGINFO";
2690 case PT_MIPS_RTPROC:
2691 return "RTPROC";
2692 case PT_MIPS_OPTIONS:
2693 return "OPTIONS";
2694 default:
2695 break;
2696 }
2697
2698 return NULL;
2699 }
2700
2701 static const char *
2702 get_parisc_segment_type (unsigned long type)
2703 {
2704 switch (type)
2705 {
2706 case PT_HP_TLS: return "HP_TLS";
2707 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
2708 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
2709 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
2710 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
2711 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
2712 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
2713 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
2714 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
2715 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
2716 case PT_HP_PARALLEL: return "HP_PARALLEL";
2717 case PT_HP_FASTBIND: return "HP_FASTBIND";
2718 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
2719 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
2720 case PT_HP_STACK: return "HP_STACK";
2721 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
2722 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
2723 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
2724 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
2725 default:
2726 break;
2727 }
2728
2729 return NULL;
2730 }
2731
2732 static const char *
2733 get_ia64_segment_type (unsigned long type)
2734 {
2735 switch (type)
2736 {
2737 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
2738 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
2739 case PT_HP_TLS: return "HP_TLS";
2740 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
2741 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
2742 case PT_IA_64_HP_STACK: return "HP_STACK";
2743 default:
2744 break;
2745 }
2746
2747 return NULL;
2748 }
2749
2750 static const char *
2751 get_tic6x_segment_type (unsigned long type)
2752 {
2753 switch (type)
2754 {
2755 case PT_C6000_PHATTR: return "C6000_PHATTR";
2756 default:
2757 break;
2758 }
2759
2760 return NULL;
2761 }
2762
2763 static const char *
2764 get_segment_type (unsigned long p_type)
2765 {
2766 static char buff[32];
2767
2768 switch (p_type)
2769 {
2770 case PT_NULL: return "NULL";
2771 case PT_LOAD: return "LOAD";
2772 case PT_DYNAMIC: return "DYNAMIC";
2773 case PT_INTERP: return "INTERP";
2774 case PT_NOTE: return "NOTE";
2775 case PT_SHLIB: return "SHLIB";
2776 case PT_PHDR: return "PHDR";
2777 case PT_TLS: return "TLS";
2778
2779 case PT_GNU_EH_FRAME:
2780 return "GNU_EH_FRAME";
2781 case PT_GNU_STACK: return "GNU_STACK";
2782 case PT_GNU_RELRO: return "GNU_RELRO";
2783
2784 default:
2785 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
2786 {
2787 const char * result;
2788
2789 switch (elf_header.e_machine)
2790 {
2791 case EM_ARM:
2792 result = get_arm_segment_type (p_type);
2793 break;
2794 case EM_MIPS:
2795 case EM_MIPS_RS3_LE:
2796 result = get_mips_segment_type (p_type);
2797 break;
2798 case EM_PARISC:
2799 result = get_parisc_segment_type (p_type);
2800 break;
2801 case EM_IA_64:
2802 result = get_ia64_segment_type (p_type);
2803 break;
2804 case EM_TI_C6000:
2805 result = get_tic6x_segment_type (p_type);
2806 break;
2807 default:
2808 result = NULL;
2809 break;
2810 }
2811
2812 if (result != NULL)
2813 return result;
2814
2815 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
2816 }
2817 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
2818 {
2819 const char * result;
2820
2821 switch (elf_header.e_machine)
2822 {
2823 case EM_PARISC:
2824 result = get_parisc_segment_type (p_type);
2825 break;
2826 case EM_IA_64:
2827 result = get_ia64_segment_type (p_type);
2828 break;
2829 default:
2830 result = NULL;
2831 break;
2832 }
2833
2834 if (result != NULL)
2835 return result;
2836
2837 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
2838 }
2839 else
2840 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
2841
2842 return buff;
2843 }
2844 }
2845
2846 static const char *
2847 get_mips_section_type_name (unsigned int sh_type)
2848 {
2849 switch (sh_type)
2850 {
2851 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
2852 case SHT_MIPS_MSYM: return "MIPS_MSYM";
2853 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
2854 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
2855 case SHT_MIPS_UCODE: return "MIPS_UCODE";
2856 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
2857 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
2858 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
2859 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
2860 case SHT_MIPS_RELD: return "MIPS_RELD";
2861 case SHT_MIPS_IFACE: return "MIPS_IFACE";
2862 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
2863 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
2864 case SHT_MIPS_SHDR: return "MIPS_SHDR";
2865 case SHT_MIPS_FDESC: return "MIPS_FDESC";
2866 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
2867 case SHT_MIPS_DENSE: return "MIPS_DENSE";
2868 case SHT_MIPS_PDESC: return "MIPS_PDESC";
2869 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
2870 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
2871 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
2872 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
2873 case SHT_MIPS_LINE: return "MIPS_LINE";
2874 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
2875 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
2876 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
2877 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
2878 case SHT_MIPS_DWARF: return "MIPS_DWARF";
2879 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
2880 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
2881 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
2882 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
2883 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
2884 case SHT_MIPS_XLATE: return "MIPS_XLATE";
2885 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
2886 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
2887 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
2888 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
2889 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
2890 default:
2891 break;
2892 }
2893 return NULL;
2894 }
2895
2896 static const char *
2897 get_parisc_section_type_name (unsigned int sh_type)
2898 {
2899 switch (sh_type)
2900 {
2901 case SHT_PARISC_EXT: return "PARISC_EXT";
2902 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
2903 case SHT_PARISC_DOC: return "PARISC_DOC";
2904 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
2905 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
2906 case SHT_PARISC_STUBS: return "PARISC_STUBS";
2907 case SHT_PARISC_DLKM: return "PARISC_DLKM";
2908 default:
2909 break;
2910 }
2911 return NULL;
2912 }
2913
2914 static const char *
2915 get_ia64_section_type_name (unsigned int sh_type)
2916 {
2917 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2918 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
2919 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
2920
2921 switch (sh_type)
2922 {
2923 case SHT_IA_64_EXT: return "IA_64_EXT";
2924 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
2925 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
2926 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
2927 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
2928 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
2929 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
2930 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
2931 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
2932 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
2933 default:
2934 break;
2935 }
2936 return NULL;
2937 }
2938
2939 static const char *
2940 get_x86_64_section_type_name (unsigned int sh_type)
2941 {
2942 switch (sh_type)
2943 {
2944 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
2945 default:
2946 break;
2947 }
2948 return NULL;
2949 }
2950
2951 static const char *
2952 get_arm_section_type_name (unsigned int sh_type)
2953 {
2954 switch (sh_type)
2955 {
2956 case SHT_ARM_EXIDX: return "ARM_EXIDX";
2957 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
2958 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
2959 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
2960 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
2961 default:
2962 break;
2963 }
2964 return NULL;
2965 }
2966
2967 static const char *
2968 get_tic6x_section_type_name (unsigned int sh_type)
2969 {
2970 switch (sh_type)
2971 {
2972 case SHT_C6000_UNWIND:
2973 return "C6000_UNWIND";
2974 case SHT_C6000_PREEMPTMAP:
2975 return "C6000_PREEMPTMAP";
2976 case SHT_C6000_ATTRIBUTES:
2977 return "C6000_ATTRIBUTES";
2978 case SHT_TI_ICODE:
2979 return "TI_ICODE";
2980 case SHT_TI_XREF:
2981 return "TI_XREF";
2982 case SHT_TI_HANDLER:
2983 return "TI_HANDLER";
2984 case SHT_TI_INITINFO:
2985 return "TI_INITINFO";
2986 case SHT_TI_PHATTRS:
2987 return "TI_PHATTRS";
2988 default:
2989 break;
2990 }
2991 return NULL;
2992 }
2993
2994 static const char *
2995 get_section_type_name (unsigned int sh_type)
2996 {
2997 static char buff[32];
2998
2999 switch (sh_type)
3000 {
3001 case SHT_NULL: return "NULL";
3002 case SHT_PROGBITS: return "PROGBITS";
3003 case SHT_SYMTAB: return "SYMTAB";
3004 case SHT_STRTAB: return "STRTAB";
3005 case SHT_RELA: return "RELA";
3006 case SHT_HASH: return "HASH";
3007 case SHT_DYNAMIC: return "DYNAMIC";
3008 case SHT_NOTE: return "NOTE";
3009 case SHT_NOBITS: return "NOBITS";
3010 case SHT_REL: return "REL";
3011 case SHT_SHLIB: return "SHLIB";
3012 case SHT_DYNSYM: return "DYNSYM";
3013 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3014 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3015 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
3016 case SHT_GNU_HASH: return "GNU_HASH";
3017 case SHT_GROUP: return "GROUP";
3018 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
3019 case SHT_GNU_verdef: return "VERDEF";
3020 case SHT_GNU_verneed: return "VERNEED";
3021 case SHT_GNU_versym: return "VERSYM";
3022 case 0x6ffffff0: return "VERSYM";
3023 case 0x6ffffffc: return "VERDEF";
3024 case 0x7ffffffd: return "AUXILIARY";
3025 case 0x7fffffff: return "FILTER";
3026 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
3027
3028 default:
3029 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3030 {
3031 const char * result;
3032
3033 switch (elf_header.e_machine)
3034 {
3035 case EM_MIPS:
3036 case EM_MIPS_RS3_LE:
3037 result = get_mips_section_type_name (sh_type);
3038 break;
3039 case EM_PARISC:
3040 result = get_parisc_section_type_name (sh_type);
3041 break;
3042 case EM_IA_64:
3043 result = get_ia64_section_type_name (sh_type);
3044 break;
3045 case EM_X86_64:
3046 case EM_L1OM:
3047 result = get_x86_64_section_type_name (sh_type);
3048 break;
3049 case EM_ARM:
3050 result = get_arm_section_type_name (sh_type);
3051 break;
3052 case EM_TI_C6000:
3053 result = get_tic6x_section_type_name (sh_type);
3054 break;
3055 default:
3056 result = NULL;
3057 break;
3058 }
3059
3060 if (result != NULL)
3061 return result;
3062
3063 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
3064 }
3065 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
3066 {
3067 const char * result;
3068
3069 switch (elf_header.e_machine)
3070 {
3071 case EM_IA_64:
3072 result = get_ia64_section_type_name (sh_type);
3073 break;
3074 default:
3075 result = NULL;
3076 break;
3077 }
3078
3079 if (result != NULL)
3080 return result;
3081
3082 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3083 }
3084 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
3085 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3086 else
3087 /* This message is probably going to be displayed in a 15
3088 character wide field, so put the hex value first. */
3089 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
3090
3091 return buff;
3092 }
3093 }
3094
3095 #define OPTION_DEBUG_DUMP 512
3096 #define OPTION_DYN_SYMS 513
3097 #define OPTION_DWARF_DEPTH 514
3098 #define OPTION_DWARF_START 515
3099
3100 static struct option options[] =
3101 {
3102 {"all", no_argument, 0, 'a'},
3103 {"file-header", no_argument, 0, 'h'},
3104 {"program-headers", no_argument, 0, 'l'},
3105 {"headers", no_argument, 0, 'e'},
3106 {"histogram", no_argument, 0, 'I'},
3107 {"segments", no_argument, 0, 'l'},
3108 {"sections", no_argument, 0, 'S'},
3109 {"section-headers", no_argument, 0, 'S'},
3110 {"section-groups", no_argument, 0, 'g'},
3111 {"section-details", no_argument, 0, 't'},
3112 {"full-section-name",no_argument, 0, 'N'},
3113 {"symbols", no_argument, 0, 's'},
3114 {"syms", no_argument, 0, 's'},
3115 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
3116 {"relocs", no_argument, 0, 'r'},
3117 {"notes", no_argument, 0, 'n'},
3118 {"dynamic", no_argument, 0, 'd'},
3119 {"arch-specific", no_argument, 0, 'A'},
3120 {"version-info", no_argument, 0, 'V'},
3121 {"use-dynamic", no_argument, 0, 'D'},
3122 {"unwind", no_argument, 0, 'u'},
3123 {"archive-index", no_argument, 0, 'c'},
3124 {"hex-dump", required_argument, 0, 'x'},
3125 {"relocated-dump", required_argument, 0, 'R'},
3126 {"string-dump", required_argument, 0, 'p'},
3127 #ifdef SUPPORT_DISASSEMBLY
3128 {"instruction-dump", required_argument, 0, 'i'},
3129 #endif
3130 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
3131
3132 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3133 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
3134
3135 {"version", no_argument, 0, 'v'},
3136 {"wide", no_argument, 0, 'W'},
3137 {"help", no_argument, 0, 'H'},
3138 {0, no_argument, 0, 0}
3139 };
3140
3141 static void
3142 usage (FILE * stream)
3143 {
3144 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3145 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3146 fprintf (stream, _(" Options are:\n\
3147 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3148 -h --file-header Display the ELF file header\n\
3149 -l --program-headers Display the program headers\n\
3150 --segments An alias for --program-headers\n\
3151 -S --section-headers Display the sections' header\n\
3152 --sections An alias for --section-headers\n\
3153 -g --section-groups Display the section groups\n\
3154 -t --section-details Display the section details\n\
3155 -e --headers Equivalent to: -h -l -S\n\
3156 -s --syms Display the symbol table\n\
3157 --symbols An alias for --syms\n\
3158 --dyn-syms Display the dynamic symbol table\n\
3159 -n --notes Display the core notes (if present)\n\
3160 -r --relocs Display the relocations (if present)\n\
3161 -u --unwind Display the unwind info (if present)\n\
3162 -d --dynamic Display the dynamic section (if present)\n\
3163 -V --version-info Display the version sections (if present)\n\
3164 -A --arch-specific Display architecture specific information (if any).\n\
3165 -c --archive-index Display the symbol/file index in an archive\n\
3166 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3167 -x --hex-dump=<number|name>\n\
3168 Dump the contents of section <number|name> as bytes\n\
3169 -p --string-dump=<number|name>\n\
3170 Dump the contents of section <number|name> as strings\n\
3171 -R --relocated-dump=<number|name>\n\
3172 Dump the contents of section <number|name> as relocated bytes\n\
3173 -w[lLiaprmfFsoRt] or\n\
3174 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3175 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3176 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges]\n\
3177 Display the contents of DWARF2 debug sections\n"));
3178 fprintf (stream, _("\
3179 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3180 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3181 or deeper\n"));
3182 #ifdef SUPPORT_DISASSEMBLY
3183 fprintf (stream, _("\
3184 -i --instruction-dump=<number|name>\n\
3185 Disassemble the contents of section <number|name>\n"));
3186 #endif
3187 fprintf (stream, _("\
3188 -I --histogram Display histogram of bucket list lengths\n\
3189 -W --wide Allow output width to exceed 80 characters\n\
3190 @<file> Read options from <file>\n\
3191 -H --help Display this information\n\
3192 -v --version Display the version number of readelf\n"));
3193
3194 if (REPORT_BUGS_TO[0] && stream == stdout)
3195 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
3196
3197 exit (stream == stdout ? 0 : 1);
3198 }
3199
3200 /* Record the fact that the user wants the contents of section number
3201 SECTION to be displayed using the method(s) encoded as flags bits
3202 in TYPE. Note, TYPE can be zero if we are creating the array for
3203 the first time. */
3204
3205 static void
3206 request_dump_bynumber (unsigned int section, dump_type type)
3207 {
3208 if (section >= num_dump_sects)
3209 {
3210 dump_type * new_dump_sects;
3211
3212 new_dump_sects = (dump_type *) calloc (section + 1,
3213 sizeof (* dump_sects));
3214
3215 if (new_dump_sects == NULL)
3216 error (_("Out of memory allocating dump request table.\n"));
3217 else
3218 {
3219 /* Copy current flag settings. */
3220 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
3221
3222 free (dump_sects);
3223
3224 dump_sects = new_dump_sects;
3225 num_dump_sects = section + 1;
3226 }
3227 }
3228
3229 if (dump_sects)
3230 dump_sects[section] |= type;
3231
3232 return;
3233 }
3234
3235 /* Request a dump by section name. */
3236
3237 static void
3238 request_dump_byname (const char * section, dump_type type)
3239 {
3240 struct dump_list_entry * new_request;
3241
3242 new_request = (struct dump_list_entry *)
3243 malloc (sizeof (struct dump_list_entry));
3244 if (!new_request)
3245 error (_("Out of memory allocating dump request table.\n"));
3246
3247 new_request->name = strdup (section);
3248 if (!new_request->name)
3249 error (_("Out of memory allocating dump request table.\n"));
3250
3251 new_request->type = type;
3252
3253 new_request->next = dump_sects_byname;
3254 dump_sects_byname = new_request;
3255 }
3256
3257 static inline void
3258 request_dump (dump_type type)
3259 {
3260 int section;
3261 char * cp;
3262
3263 do_dump++;
3264 section = strtoul (optarg, & cp, 0);
3265
3266 if (! *cp && section >= 0)
3267 request_dump_bynumber (section, type);
3268 else
3269 request_dump_byname (optarg, type);
3270 }
3271
3272
3273 static void
3274 parse_args (int argc, char ** argv)
3275 {
3276 int c;
3277
3278 if (argc < 2)
3279 usage (stderr);
3280
3281 while ((c = getopt_long
3282 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
3283 {
3284 switch (c)
3285 {
3286 case 0:
3287 /* Long options. */
3288 break;
3289 case 'H':
3290 usage (stdout);
3291 break;
3292
3293 case 'a':
3294 do_syms++;
3295 do_reloc++;
3296 do_unwind++;
3297 do_dynamic++;
3298 do_header++;
3299 do_sections++;
3300 do_section_groups++;
3301 do_segments++;
3302 do_version++;
3303 do_histogram++;
3304 do_arch++;
3305 do_notes++;
3306 break;
3307 case 'g':
3308 do_section_groups++;
3309 break;
3310 case 't':
3311 case 'N':
3312 do_sections++;
3313 do_section_details++;
3314 break;
3315 case 'e':
3316 do_header++;
3317 do_sections++;
3318 do_segments++;
3319 break;
3320 case 'A':
3321 do_arch++;
3322 break;
3323 case 'D':
3324 do_using_dynamic++;
3325 break;
3326 case 'r':
3327 do_reloc++;
3328 break;
3329 case 'u':
3330 do_unwind++;
3331 break;
3332 case 'h':
3333 do_header++;
3334 break;
3335 case 'l':
3336 do_segments++;
3337 break;
3338 case 's':
3339 do_syms++;
3340 break;
3341 case 'S':
3342 do_sections++;
3343 break;
3344 case 'd':
3345 do_dynamic++;
3346 break;
3347 case 'I':
3348 do_histogram++;
3349 break;
3350 case 'n':
3351 do_notes++;
3352 break;
3353 case 'c':
3354 do_archive_index++;
3355 break;
3356 case 'x':
3357 request_dump (HEX_DUMP);
3358 break;
3359 case 'p':
3360 request_dump (STRING_DUMP);
3361 break;
3362 case 'R':
3363 request_dump (RELOC_DUMP);
3364 break;
3365 case 'w':
3366 do_dump++;
3367 if (optarg == 0)
3368 {
3369 do_debugging = 1;
3370 dwarf_select_sections_all ();
3371 }
3372 else
3373 {
3374 do_debugging = 0;
3375 dwarf_select_sections_by_letters (optarg);
3376 }
3377 break;
3378 case OPTION_DEBUG_DUMP:
3379 do_dump++;
3380 if (optarg == 0)
3381 do_debugging = 1;
3382 else
3383 {
3384 do_debugging = 0;
3385 dwarf_select_sections_by_names (optarg);
3386 }
3387 break;
3388 case OPTION_DWARF_DEPTH:
3389 {
3390 char *cp;
3391
3392 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3393 }
3394 break;
3395 case OPTION_DWARF_START:
3396 {
3397 char *cp;
3398
3399 dwarf_start_die = strtoul (optarg, & cp, 0);
3400 }
3401 break;
3402 case OPTION_DYN_SYMS:
3403 do_dyn_syms++;
3404 break;
3405 #ifdef SUPPORT_DISASSEMBLY
3406 case 'i':
3407 request_dump (DISASS_DUMP);
3408 break;
3409 #endif
3410 case 'v':
3411 print_version (program_name);
3412 break;
3413 case 'V':
3414 do_version++;
3415 break;
3416 case 'W':
3417 do_wide++;
3418 break;
3419 default:
3420 /* xgettext:c-format */
3421 error (_("Invalid option '-%c'\n"), c);
3422 /* Drop through. */
3423 case '?':
3424 usage (stderr);
3425 }
3426 }
3427
3428 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
3429 && !do_segments && !do_header && !do_dump && !do_version
3430 && !do_histogram && !do_debugging && !do_arch && !do_notes
3431 && !do_section_groups && !do_archive_index
3432 && !do_dyn_syms)
3433 usage (stderr);
3434 else if (argc < 3)
3435 {
3436 warn (_("Nothing to do.\n"));
3437 usage (stderr);
3438 }
3439 }
3440
3441 static const char *
3442 get_elf_class (unsigned int elf_class)
3443 {
3444 static char buff[32];
3445
3446 switch (elf_class)
3447 {
3448 case ELFCLASSNONE: return _("none");
3449 case ELFCLASS32: return "ELF32";
3450 case ELFCLASS64: return "ELF64";
3451 default:
3452 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
3453 return buff;
3454 }
3455 }
3456
3457 static const char *
3458 get_data_encoding (unsigned int encoding)
3459 {
3460 static char buff[32];
3461
3462 switch (encoding)
3463 {
3464 case ELFDATANONE: return _("none");
3465 case ELFDATA2LSB: return _("2's complement, little endian");
3466 case ELFDATA2MSB: return _("2's complement, big endian");
3467 default:
3468 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
3469 return buff;
3470 }
3471 }
3472
3473 /* Decode the data held in 'elf_header'. */
3474
3475 static int
3476 process_file_header (void)
3477 {
3478 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
3479 || elf_header.e_ident[EI_MAG1] != ELFMAG1
3480 || elf_header.e_ident[EI_MAG2] != ELFMAG2
3481 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
3482 {
3483 error
3484 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3485 return 0;
3486 }
3487
3488 init_dwarf_regnames (elf_header.e_machine);
3489
3490 if (do_header)
3491 {
3492 int i;
3493
3494 printf (_("ELF Header:\n"));
3495 printf (_(" Magic: "));
3496 for (i = 0; i < EI_NIDENT; i++)
3497 printf ("%2.2x ", elf_header.e_ident[i]);
3498 printf ("\n");
3499 printf (_(" Class: %s\n"),
3500 get_elf_class (elf_header.e_ident[EI_CLASS]));
3501 printf (_(" Data: %s\n"),
3502 get_data_encoding (elf_header.e_ident[EI_DATA]));
3503 printf (_(" Version: %d %s\n"),
3504 elf_header.e_ident[EI_VERSION],
3505 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
3506 ? "(current)"
3507 : (elf_header.e_ident[EI_VERSION] != EV_NONE
3508 ? _("<unknown: %lx>")
3509 : "")));
3510 printf (_(" OS/ABI: %s\n"),
3511 get_osabi_name (elf_header.e_ident[EI_OSABI]));
3512 printf (_(" ABI Version: %d\n"),
3513 elf_header.e_ident[EI_ABIVERSION]);
3514 printf (_(" Type: %s\n"),
3515 get_file_type (elf_header.e_type));
3516 printf (_(" Machine: %s\n"),
3517 get_machine_name (elf_header.e_machine));
3518 printf (_(" Version: 0x%lx\n"),
3519 (unsigned long) elf_header.e_version);
3520
3521 printf (_(" Entry point address: "));
3522 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3523 printf (_("\n Start of program headers: "));
3524 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3525 printf (_(" (bytes into file)\n Start of section headers: "));
3526 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3527 printf (_(" (bytes into file)\n"));
3528
3529 printf (_(" Flags: 0x%lx%s\n"),
3530 (unsigned long) elf_header.e_flags,
3531 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3532 printf (_(" Size of this header: %ld (bytes)\n"),
3533 (long) elf_header.e_ehsize);
3534 printf (_(" Size of program headers: %ld (bytes)\n"),
3535 (long) elf_header.e_phentsize);
3536 printf (_(" Number of program headers: %ld"),
3537 (long) elf_header.e_phnum);
3538 if (section_headers != NULL
3539 && elf_header.e_phnum == PN_XNUM
3540 && section_headers[0].sh_info != 0)
3541 printf (" (%ld)", (long) section_headers[0].sh_info);
3542 putc ('\n', stdout);
3543 printf (_(" Size of section headers: %ld (bytes)\n"),
3544 (long) elf_header.e_shentsize);
3545 printf (_(" Number of section headers: %ld"),
3546 (long) elf_header.e_shnum);
3547 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
3548 printf (" (%ld)", (long) section_headers[0].sh_size);
3549 putc ('\n', stdout);
3550 printf (_(" Section header string table index: %ld"),
3551 (long) elf_header.e_shstrndx);
3552 if (section_headers != NULL
3553 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3554 printf (" (%u)", section_headers[0].sh_link);
3555 else if (elf_header.e_shstrndx != SHN_UNDEF
3556 && elf_header.e_shstrndx >= elf_header.e_shnum)
3557 printf (_(" <corrupt: out of range>"));
3558 putc ('\n', stdout);
3559 }
3560
3561 if (section_headers != NULL)
3562 {
3563 if (elf_header.e_phnum == PN_XNUM
3564 && section_headers[0].sh_info != 0)
3565 elf_header.e_phnum = section_headers[0].sh_info;
3566 if (elf_header.e_shnum == SHN_UNDEF)
3567 elf_header.e_shnum = section_headers[0].sh_size;
3568 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3569 elf_header.e_shstrndx = section_headers[0].sh_link;
3570 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
3571 elf_header.e_shstrndx = SHN_UNDEF;
3572 free (section_headers);
3573 section_headers = NULL;
3574 }
3575
3576 return 1;
3577 }
3578
3579
3580 static int
3581 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
3582 {
3583 Elf32_External_Phdr * phdrs;
3584 Elf32_External_Phdr * external;
3585 Elf_Internal_Phdr * internal;
3586 unsigned int i;
3587
3588 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3589 elf_header.e_phentsize,
3590 elf_header.e_phnum,
3591 _("program headers"));
3592 if (!phdrs)
3593 return 0;
3594
3595 for (i = 0, internal = pheaders, external = phdrs;
3596 i < elf_header.e_phnum;
3597 i++, internal++, external++)
3598 {
3599 internal->p_type = BYTE_GET (external->p_type);
3600 internal->p_offset = BYTE_GET (external->p_offset);
3601 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3602 internal->p_paddr = BYTE_GET (external->p_paddr);
3603 internal->p_filesz = BYTE_GET (external->p_filesz);
3604 internal->p_memsz = BYTE_GET (external->p_memsz);
3605 internal->p_flags = BYTE_GET (external->p_flags);
3606 internal->p_align = BYTE_GET (external->p_align);
3607 }
3608
3609 free (phdrs);
3610
3611 return 1;
3612 }
3613
3614 static int
3615 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
3616 {
3617 Elf64_External_Phdr * phdrs;
3618 Elf64_External_Phdr * external;
3619 Elf_Internal_Phdr * internal;
3620 unsigned int i;
3621
3622 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3623 elf_header.e_phentsize,
3624 elf_header.e_phnum,
3625 _("program headers"));
3626 if (!phdrs)
3627 return 0;
3628
3629 for (i = 0, internal = pheaders, external = phdrs;
3630 i < elf_header.e_phnum;
3631 i++, internal++, external++)
3632 {
3633 internal->p_type = BYTE_GET (external->p_type);
3634 internal->p_flags = BYTE_GET (external->p_flags);
3635 internal->p_offset = BYTE_GET (external->p_offset);
3636 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3637 internal->p_paddr = BYTE_GET (external->p_paddr);
3638 internal->p_filesz = BYTE_GET (external->p_filesz);
3639 internal->p_memsz = BYTE_GET (external->p_memsz);
3640 internal->p_align = BYTE_GET (external->p_align);
3641 }
3642
3643 free (phdrs);
3644
3645 return 1;
3646 }
3647
3648 /* Returns 1 if the program headers were read into `program_headers'. */
3649
3650 static int
3651 get_program_headers (FILE * file)
3652 {
3653 Elf_Internal_Phdr * phdrs;
3654
3655 /* Check cache of prior read. */
3656 if (program_headers != NULL)
3657 return 1;
3658
3659 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
3660 sizeof (Elf_Internal_Phdr));
3661
3662 if (phdrs == NULL)
3663 {
3664 error (_("Out of memory\n"));
3665 return 0;
3666 }
3667
3668 if (is_32bit_elf
3669 ? get_32bit_program_headers (file, phdrs)
3670 : get_64bit_program_headers (file, phdrs))
3671 {
3672 program_headers = phdrs;
3673 return 1;
3674 }
3675
3676 free (phdrs);
3677 return 0;
3678 }
3679
3680 /* Returns 1 if the program headers were loaded. */
3681
3682 static int
3683 process_program_headers (FILE * file)
3684 {
3685 Elf_Internal_Phdr * segment;
3686 unsigned int i;
3687
3688 if (elf_header.e_phnum == 0)
3689 {
3690 /* PR binutils/12467. */
3691 if (elf_header.e_phoff != 0)
3692 warn (_("possibly corrupt ELF header - it has a non-zero program"
3693 " header offset, but no program headers"));
3694 else if (do_segments)
3695 printf (_("\nThere are no program headers in this file.\n"));
3696 return 0;
3697 }
3698
3699 if (do_segments && !do_header)
3700 {
3701 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3702 printf (_("Entry point "));
3703 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3704 printf (_("\nThere are %d program headers, starting at offset "),
3705 elf_header.e_phnum);
3706 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3707 printf ("\n");
3708 }
3709
3710 if (! get_program_headers (file))
3711 return 0;
3712
3713 if (do_segments)
3714 {
3715 if (elf_header.e_phnum > 1)
3716 printf (_("\nProgram Headers:\n"));
3717 else
3718 printf (_("\nProgram Headers:\n"));
3719
3720 if (is_32bit_elf)
3721 printf
3722 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3723 else if (do_wide)
3724 printf
3725 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3726 else
3727 {
3728 printf
3729 (_(" Type Offset VirtAddr PhysAddr\n"));
3730 printf
3731 (_(" FileSiz MemSiz Flags Align\n"));
3732 }
3733 }
3734
3735 dynamic_addr = 0;
3736 dynamic_size = 0;
3737
3738 for (i = 0, segment = program_headers;
3739 i < elf_header.e_phnum;
3740 i++, segment++)
3741 {
3742 if (do_segments)
3743 {
3744 printf (" %-14.14s ", get_segment_type (segment->p_type));
3745
3746 if (is_32bit_elf)
3747 {
3748 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3749 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
3750 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
3751 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3752 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3753 printf ("%c%c%c ",
3754 (segment->p_flags & PF_R ? 'R' : ' '),
3755 (segment->p_flags & PF_W ? 'W' : ' '),
3756 (segment->p_flags & PF_X ? 'E' : ' '));
3757 printf ("%#lx", (unsigned long) segment->p_align);
3758 }
3759 else if (do_wide)
3760 {
3761 if ((unsigned long) segment->p_offset == segment->p_offset)
3762 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3763 else
3764 {
3765 print_vma (segment->p_offset, FULL_HEX);
3766 putchar (' ');
3767 }
3768
3769 print_vma (segment->p_vaddr, FULL_HEX);
3770 putchar (' ');
3771 print_vma (segment->p_paddr, FULL_HEX);
3772 putchar (' ');
3773
3774 if ((unsigned long) segment->p_filesz == segment->p_filesz)
3775 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
3776 else
3777 {
3778 print_vma (segment->p_filesz, FULL_HEX);
3779 putchar (' ');
3780 }
3781
3782 if ((unsigned long) segment->p_memsz == segment->p_memsz)
3783 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
3784 else
3785 {
3786 print_vma (segment->p_offset, FULL_HEX);
3787 }
3788
3789 printf (" %c%c%c ",
3790 (segment->p_flags & PF_R ? 'R' : ' '),
3791 (segment->p_flags & PF_W ? 'W' : ' '),
3792 (segment->p_flags & PF_X ? 'E' : ' '));
3793
3794 if ((unsigned long) segment->p_align == segment->p_align)
3795 printf ("%#lx", (unsigned long) segment->p_align);
3796 else
3797 {
3798 print_vma (segment->p_align, PREFIX_HEX);
3799 }
3800 }
3801 else
3802 {
3803 print_vma (segment->p_offset, FULL_HEX);
3804 putchar (' ');
3805 print_vma (segment->p_vaddr, FULL_HEX);
3806 putchar (' ');
3807 print_vma (segment->p_paddr, FULL_HEX);
3808 printf ("\n ");
3809 print_vma (segment->p_filesz, FULL_HEX);
3810 putchar (' ');
3811 print_vma (segment->p_memsz, FULL_HEX);
3812 printf (" %c%c%c ",
3813 (segment->p_flags & PF_R ? 'R' : ' '),
3814 (segment->p_flags & PF_W ? 'W' : ' '),
3815 (segment->p_flags & PF_X ? 'E' : ' '));
3816 print_vma (segment->p_align, HEX);
3817 }
3818 }
3819
3820 switch (segment->p_type)
3821 {
3822 case PT_DYNAMIC:
3823 if (dynamic_addr)
3824 error (_("more than one dynamic segment\n"));
3825
3826 /* By default, assume that the .dynamic section is the first
3827 section in the DYNAMIC segment. */
3828 dynamic_addr = segment->p_offset;
3829 dynamic_size = segment->p_filesz;
3830
3831 /* Try to locate the .dynamic section. If there is
3832 a section header table, we can easily locate it. */
3833 if (section_headers != NULL)
3834 {
3835 Elf_Internal_Shdr * sec;
3836
3837 sec = find_section (".dynamic");
3838 if (sec == NULL || sec->sh_size == 0)
3839 {
3840 /* A corresponding .dynamic section is expected, but on
3841 IA-64/OpenVMS it is OK for it to be missing. */
3842 if (!is_ia64_vms ())
3843 error (_("no .dynamic section in the dynamic segment\n"));
3844 break;
3845 }
3846
3847 if (sec->sh_type == SHT_NOBITS)
3848 {
3849 dynamic_size = 0;
3850 break;
3851 }
3852
3853 dynamic_addr = sec->sh_offset;
3854 dynamic_size = sec->sh_size;
3855
3856 if (dynamic_addr < segment->p_offset
3857 || dynamic_addr > segment->p_offset + segment->p_filesz)
3858 warn (_("the .dynamic section is not contained"
3859 " within the dynamic segment\n"));
3860 else if (dynamic_addr > segment->p_offset)
3861 warn (_("the .dynamic section is not the first section"
3862 " in the dynamic segment.\n"));
3863 }
3864 break;
3865
3866 case PT_INTERP:
3867 if (fseek (file, archive_file_offset + (long) segment->p_offset,
3868 SEEK_SET))
3869 error (_("Unable to find program interpreter name\n"));
3870 else
3871 {
3872 char fmt [32];
3873 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
3874
3875 if (ret >= (int) sizeof (fmt) || ret < 0)
3876 error (_("Internal error: failed to create format string to display program interpreter\n"));
3877
3878 program_interpreter[0] = 0;
3879 if (fscanf (file, fmt, program_interpreter) <= 0)
3880 error (_("Unable to read program interpreter name\n"));
3881
3882 if (do_segments)
3883 printf (_("\n [Requesting program interpreter: %s]"),
3884 program_interpreter);
3885 }
3886 break;
3887 }
3888
3889 if (do_segments)
3890 putc ('\n', stdout);
3891 }
3892
3893 if (do_segments && section_headers != NULL && string_table != NULL)
3894 {
3895 printf (_("\n Section to Segment mapping:\n"));
3896 printf (_(" Segment Sections...\n"));
3897
3898 for (i = 0; i < elf_header.e_phnum; i++)
3899 {
3900 unsigned int j;
3901 Elf_Internal_Shdr * section;
3902
3903 segment = program_headers + i;
3904 section = section_headers + 1;
3905
3906 printf (" %2.2d ", i);
3907
3908 for (j = 1; j < elf_header.e_shnum; j++, section++)
3909 {
3910 if (!ELF_TBSS_SPECIAL (section, segment)
3911 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
3912 printf ("%s ", SECTION_NAME (section));
3913 }
3914
3915 putc ('\n',stdout);
3916 }
3917 }
3918
3919 return 1;
3920 }
3921
3922
3923 /* Find the file offset corresponding to VMA by using the program headers. */
3924
3925 static long
3926 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
3927 {
3928 Elf_Internal_Phdr * seg;
3929
3930 if (! get_program_headers (file))
3931 {
3932 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3933 return (long) vma;
3934 }
3935
3936 for (seg = program_headers;
3937 seg < program_headers + elf_header.e_phnum;
3938 ++seg)
3939 {
3940 if (seg->p_type != PT_LOAD)
3941 continue;
3942
3943 if (vma >= (seg->p_vaddr & -seg->p_align)
3944 && vma + size <= seg->p_vaddr + seg->p_filesz)
3945 return vma - seg->p_vaddr + seg->p_offset;
3946 }
3947
3948 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3949 (unsigned long) vma);
3950 return (long) vma;
3951 }
3952
3953
3954 static int
3955 get_32bit_section_headers (FILE * file, unsigned int num)
3956 {
3957 Elf32_External_Shdr * shdrs;
3958 Elf_Internal_Shdr * internal;
3959 unsigned int i;
3960
3961 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
3962 elf_header.e_shentsize, num,
3963 _("section headers"));
3964 if (!shdrs)
3965 return 0;
3966
3967 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
3968 sizeof (Elf_Internal_Shdr));
3969
3970 if (section_headers == NULL)
3971 {
3972 error (_("Out of memory\n"));
3973 return 0;
3974 }
3975
3976 for (i = 0, internal = section_headers;
3977 i < num;
3978 i++, internal++)
3979 {
3980 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3981 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3982 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
3983 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
3984 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3985 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
3986 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3987 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3988 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3989 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
3990 }
3991
3992 free (shdrs);
3993
3994 return 1;
3995 }
3996
3997 static int
3998 get_64bit_section_headers (FILE * file, unsigned int num)
3999 {
4000 Elf64_External_Shdr * shdrs;
4001 Elf_Internal_Shdr * internal;
4002 unsigned int i;
4003
4004 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4005 elf_header.e_shentsize, num,
4006 _("section headers"));
4007 if (!shdrs)
4008 return 0;
4009
4010 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4011 sizeof (Elf_Internal_Shdr));
4012
4013 if (section_headers == NULL)
4014 {
4015 error (_("Out of memory\n"));
4016 return 0;
4017 }
4018
4019 for (i = 0, internal = section_headers;
4020 i < num;
4021 i++, internal++)
4022 {
4023 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4024 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4025 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4026 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4027 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4028 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4029 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4030 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4031 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4032 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4033 }
4034
4035 free (shdrs);
4036
4037 return 1;
4038 }
4039
4040 static Elf_Internal_Sym *
4041 get_32bit_elf_symbols (FILE * file, Elf_Internal_Shdr * section)
4042 {
4043 unsigned long number;
4044 Elf32_External_Sym * esyms = NULL;
4045 Elf_External_Sym_Shndx * shndx;
4046 Elf_Internal_Sym * isyms = NULL;
4047 Elf_Internal_Sym * psym;
4048 unsigned int j;
4049
4050 /* Run some sanity checks first. */
4051 if (section->sh_entsize == 0)
4052 {
4053 error (_("sh_entsize is zero\n"));
4054 return NULL;
4055 }
4056
4057 number = section->sh_size / section->sh_entsize;
4058
4059 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4060 {
4061 error (_("Invalid sh_entsize\n"));
4062 return NULL;
4063 }
4064
4065 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4066 section->sh_size, _("symbols"));
4067 if (esyms == NULL)
4068 return NULL;
4069
4070 shndx = NULL;
4071 if (symtab_shndx_hdr != NULL
4072 && (symtab_shndx_hdr->sh_link
4073 == (unsigned long) (section - section_headers)))
4074 {
4075 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4076 symtab_shndx_hdr->sh_offset,
4077 1, symtab_shndx_hdr->sh_size,
4078 _("symtab shndx"));
4079 if (shndx == NULL)
4080 goto exit_point;
4081 }
4082
4083 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4084
4085 if (isyms == NULL)
4086 {
4087 error (_("Out of memory\n"));
4088 goto exit_point;
4089 }
4090
4091 for (j = 0, psym = isyms; j < number; j++, psym++)
4092 {
4093 psym->st_name = BYTE_GET (esyms[j].st_name);
4094 psym->st_value = BYTE_GET (esyms[j].st_value);
4095 psym->st_size = BYTE_GET (esyms[j].st_size);
4096 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4097 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4098 psym->st_shndx
4099 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4100 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4101 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4102 psym->st_info = BYTE_GET (esyms[j].st_info);
4103 psym->st_other = BYTE_GET (esyms[j].st_other);
4104 }
4105
4106 exit_point:
4107 if (shndx)
4108 free (shndx);
4109 if (esyms)
4110 free (esyms);
4111
4112 return isyms;
4113 }
4114
4115 static Elf_Internal_Sym *
4116 get_64bit_elf_symbols (FILE * file, Elf_Internal_Shdr * section)
4117 {
4118 unsigned long number;
4119 Elf64_External_Sym * esyms;
4120 Elf_External_Sym_Shndx * shndx;
4121 Elf_Internal_Sym * isyms;
4122 Elf_Internal_Sym * psym;
4123 unsigned int j;
4124
4125 /* Run some sanity checks first. */
4126 if (section->sh_entsize == 0)
4127 {
4128 error (_("sh_entsize is zero\n"));
4129 return NULL;
4130 }
4131
4132 number = section->sh_size / section->sh_entsize;
4133
4134 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4135 {
4136 error (_("Invalid sh_entsize\n"));
4137 return NULL;
4138 }
4139
4140 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4141 section->sh_size, _("symbols"));
4142 if (!esyms)
4143 return NULL;
4144
4145 shndx = NULL;
4146 if (symtab_shndx_hdr != NULL
4147 && (symtab_shndx_hdr->sh_link
4148 == (unsigned long) (section - section_headers)))
4149 {
4150 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4151 symtab_shndx_hdr->sh_offset,
4152 1, symtab_shndx_hdr->sh_size,
4153 _("symtab shndx"));
4154 if (!shndx)
4155 {
4156 free (esyms);
4157 return NULL;
4158 }
4159 }
4160
4161 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4162
4163 if (isyms == NULL)
4164 {
4165 error (_("Out of memory\n"));
4166 if (shndx)
4167 free (shndx);
4168 free (esyms);
4169 return NULL;
4170 }
4171
4172 for (j = 0, psym = isyms;
4173 j < number;
4174 j++, psym++)
4175 {
4176 psym->st_name = BYTE_GET (esyms[j].st_name);
4177 psym->st_info = BYTE_GET (esyms[j].st_info);
4178 psym->st_other = BYTE_GET (esyms[j].st_other);
4179 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4180 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4181 psym->st_shndx
4182 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4183 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4184 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4185 psym->st_value = BYTE_GET (esyms[j].st_value);
4186 psym->st_size = BYTE_GET (esyms[j].st_size);
4187 }
4188
4189 if (shndx)
4190 free (shndx);
4191 free (esyms);
4192
4193 return isyms;
4194 }
4195
4196 static const char *
4197 get_elf_section_flags (bfd_vma sh_flags)
4198 {
4199 static char buff[1024];
4200 char * p = buff;
4201 int field_size = is_32bit_elf ? 8 : 16;
4202 int sindex;
4203 int size = sizeof (buff) - (field_size + 4 + 1);
4204 bfd_vma os_flags = 0;
4205 bfd_vma proc_flags = 0;
4206 bfd_vma unknown_flags = 0;
4207 static const struct
4208 {
4209 const char * str;
4210 int len;
4211 }
4212 flags [] =
4213 {
4214 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4215 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4216 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4217 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4218 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4219 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4220 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4221 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4222 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4223 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4224 /* IA-64 specific. */
4225 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4226 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4227 /* IA-64 OpenVMS specific. */
4228 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4229 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4230 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4231 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4232 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4233 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4234 /* Generic. */
4235 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4236 /* SPARC specific. */
4237 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4238 };
4239
4240 if (do_section_details)
4241 {
4242 sprintf (buff, "[%*.*lx]: ",
4243 field_size, field_size, (unsigned long) sh_flags);
4244 p += field_size + 4;
4245 }
4246
4247 while (sh_flags)
4248 {
4249 bfd_vma flag;
4250
4251 flag = sh_flags & - sh_flags;
4252 sh_flags &= ~ flag;
4253
4254 if (do_section_details)
4255 {
4256 switch (flag)
4257 {
4258 case SHF_WRITE: sindex = 0; break;
4259 case SHF_ALLOC: sindex = 1; break;
4260 case SHF_EXECINSTR: sindex = 2; break;
4261 case SHF_MERGE: sindex = 3; break;
4262 case SHF_STRINGS: sindex = 4; break;
4263 case SHF_INFO_LINK: sindex = 5; break;
4264 case SHF_LINK_ORDER: sindex = 6; break;
4265 case SHF_OS_NONCONFORMING: sindex = 7; break;
4266 case SHF_GROUP: sindex = 8; break;
4267 case SHF_TLS: sindex = 9; break;
4268 case SHF_EXCLUDE: sindex = 18; break;
4269
4270 default:
4271 sindex = -1;
4272 switch (elf_header.e_machine)
4273 {
4274 case EM_IA_64:
4275 if (flag == SHF_IA_64_SHORT)
4276 sindex = 10;
4277 else if (flag == SHF_IA_64_NORECOV)
4278 sindex = 11;
4279 #ifdef BFD64
4280 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4281 switch (flag)
4282 {
4283 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
4284 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
4285 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
4286 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
4287 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4288 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
4289 default: break;
4290 }
4291 #endif
4292 break;
4293
4294 case EM_386:
4295 case EM_486:
4296 case EM_X86_64:
4297 case EM_L1OM:
4298 case EM_OLD_SPARCV9:
4299 case EM_SPARC32PLUS:
4300 case EM_SPARCV9:
4301 case EM_SPARC:
4302 if (flag == SHF_ORDERED)
4303 sindex = 19;
4304 break;
4305 default:
4306 break;
4307 }
4308 }
4309
4310 if (sindex != -1)
4311 {
4312 if (p != buff + field_size + 4)
4313 {
4314 if (size < (10 + 2))
4315 abort ();
4316 size -= 2;
4317 *p++ = ',';
4318 *p++ = ' ';
4319 }
4320
4321 size -= flags [sindex].len;
4322 p = stpcpy (p, flags [sindex].str);
4323 }
4324 else if (flag & SHF_MASKOS)
4325 os_flags |= flag;
4326 else if (flag & SHF_MASKPROC)
4327 proc_flags |= flag;
4328 else
4329 unknown_flags |= flag;
4330 }
4331 else
4332 {
4333 switch (flag)
4334 {
4335 case SHF_WRITE: *p = 'W'; break;
4336 case SHF_ALLOC: *p = 'A'; break;
4337 case SHF_EXECINSTR: *p = 'X'; break;
4338 case SHF_MERGE: *p = 'M'; break;
4339 case SHF_STRINGS: *p = 'S'; break;
4340 case SHF_INFO_LINK: *p = 'I'; break;
4341 case SHF_LINK_ORDER: *p = 'L'; break;
4342 case SHF_OS_NONCONFORMING: *p = 'O'; break;
4343 case SHF_GROUP: *p = 'G'; break;
4344 case SHF_TLS: *p = 'T'; break;
4345 case SHF_EXCLUDE: *p = 'E'; break;
4346
4347 default:
4348 if ((elf_header.e_machine == EM_X86_64
4349 || elf_header.e_machine == EM_L1OM)
4350 && flag == SHF_X86_64_LARGE)
4351 *p = 'l';
4352 else if (flag & SHF_MASKOS)
4353 {
4354 *p = 'o';
4355 sh_flags &= ~ SHF_MASKOS;
4356 }
4357 else if (flag & SHF_MASKPROC)
4358 {
4359 *p = 'p';
4360 sh_flags &= ~ SHF_MASKPROC;
4361 }
4362 else
4363 *p = 'x';
4364 break;
4365 }
4366 p++;
4367 }
4368 }
4369
4370 if (do_section_details)
4371 {
4372 if (os_flags)
4373 {
4374 size -= 5 + field_size;
4375 if (p != buff + field_size + 4)
4376 {
4377 if (size < (2 + 1))
4378 abort ();
4379 size -= 2;
4380 *p++ = ',';
4381 *p++ = ' ';
4382 }
4383 sprintf (p, "OS (%*.*lx)", field_size, field_size,
4384 (unsigned long) os_flags);
4385 p += 5 + field_size;
4386 }
4387 if (proc_flags)
4388 {
4389 size -= 7 + field_size;
4390 if (p != buff + field_size + 4)
4391 {
4392 if (size < (2 + 1))
4393 abort ();
4394 size -= 2;
4395 *p++ = ',';
4396 *p++ = ' ';
4397 }
4398 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4399 (unsigned long) proc_flags);
4400 p += 7 + field_size;
4401 }
4402 if (unknown_flags)
4403 {
4404 size -= 10 + field_size;
4405 if (p != buff + field_size + 4)
4406 {
4407 if (size < (2 + 1))
4408 abort ();
4409 size -= 2;
4410 *p++ = ',';
4411 *p++ = ' ';
4412 }
4413 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
4414 (unsigned long) unknown_flags);
4415 p += 10 + field_size;
4416 }
4417 }
4418
4419 *p = '\0';
4420 return buff;
4421 }
4422
4423 static int
4424 process_section_headers (FILE * file)
4425 {
4426 Elf_Internal_Shdr * section;
4427 unsigned int i;
4428
4429 section_headers = NULL;
4430
4431 if (elf_header.e_shnum == 0)
4432 {
4433 /* PR binutils/12467. */
4434 if (elf_header.e_shoff != 0)
4435 warn (_("possibly corrupt ELF file header - it has a non-zero"
4436 " section header offset, but no section headers\n"));
4437 else if (do_sections)
4438 printf (_("\nThere are no sections in this file.\n"));
4439
4440 return 1;
4441 }
4442
4443 if (do_sections && !do_header)
4444 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4445 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4446
4447 if (is_32bit_elf)
4448 {
4449 if (! get_32bit_section_headers (file, elf_header.e_shnum))
4450 return 0;
4451 }
4452 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
4453 return 0;
4454
4455 /* Read in the string table, so that we have names to display. */
4456 if (elf_header.e_shstrndx != SHN_UNDEF
4457 && elf_header.e_shstrndx < elf_header.e_shnum)
4458 {
4459 section = section_headers + elf_header.e_shstrndx;
4460
4461 if (section->sh_size != 0)
4462 {
4463 string_table = (char *) get_data (NULL, file, section->sh_offset,
4464 1, section->sh_size,
4465 _("string table"));
4466
4467 string_table_length = string_table != NULL ? section->sh_size : 0;
4468 }
4469 }
4470
4471 /* Scan the sections for the dynamic symbol table
4472 and dynamic string table and debug sections. */
4473 dynamic_symbols = NULL;
4474 dynamic_strings = NULL;
4475 dynamic_syminfo = NULL;
4476 symtab_shndx_hdr = NULL;
4477
4478 eh_addr_size = is_32bit_elf ? 4 : 8;
4479 switch (elf_header.e_machine)
4480 {
4481 case EM_MIPS:
4482 case EM_MIPS_RS3_LE:
4483 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4484 FDE addresses. However, the ABI also has a semi-official ILP32
4485 variant for which the normal FDE address size rules apply.
4486
4487 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4488 section, where XX is the size of longs in bits. Unfortunately,
4489 earlier compilers provided no way of distinguishing ILP32 objects
4490 from LP64 objects, so if there's any doubt, we should assume that
4491 the official LP64 form is being used. */
4492 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4493 && find_section (".gcc_compiled_long32") == NULL)
4494 eh_addr_size = 8;
4495 break;
4496
4497 case EM_H8_300:
4498 case EM_H8_300H:
4499 switch (elf_header.e_flags & EF_H8_MACH)
4500 {
4501 case E_H8_MACH_H8300:
4502 case E_H8_MACH_H8300HN:
4503 case E_H8_MACH_H8300SN:
4504 case E_H8_MACH_H8300SXN:
4505 eh_addr_size = 2;
4506 break;
4507 case E_H8_MACH_H8300H:
4508 case E_H8_MACH_H8300S:
4509 case E_H8_MACH_H8300SX:
4510 eh_addr_size = 4;
4511 break;
4512 }
4513 break;
4514
4515 case EM_M32C_OLD:
4516 case EM_M32C:
4517 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
4518 {
4519 case EF_M32C_CPU_M16C:
4520 eh_addr_size = 2;
4521 break;
4522 }
4523 break;
4524 }
4525
4526 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4527 do \
4528 { \
4529 size_t expected_entsize \
4530 = is_32bit_elf ? size32 : size64; \
4531 if (section->sh_entsize != expected_entsize) \
4532 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4533 i, (unsigned long int) section->sh_entsize, \
4534 (unsigned long int) expected_entsize); \
4535 section->sh_entsize = expected_entsize; \
4536 } \
4537 while (0)
4538 #define CHECK_ENTSIZE(section, i, type) \
4539 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4540 sizeof (Elf64_External_##type))
4541
4542 for (i = 0, section = section_headers;
4543 i < elf_header.e_shnum;
4544 i++, section++)
4545 {
4546 char * name = SECTION_NAME (section);
4547
4548 if (section->sh_type == SHT_DYNSYM)
4549 {
4550 if (dynamic_symbols != NULL)
4551 {
4552 error (_("File contains multiple dynamic symbol tables\n"));
4553 continue;
4554 }
4555
4556 CHECK_ENTSIZE (section, i, Sym);
4557 num_dynamic_syms = section->sh_size / section->sh_entsize;
4558 dynamic_symbols = GET_ELF_SYMBOLS (file, section);
4559 }
4560 else if (section->sh_type == SHT_STRTAB
4561 && streq (name, ".dynstr"))
4562 {
4563 if (dynamic_strings != NULL)
4564 {
4565 error (_("File contains multiple dynamic string tables\n"));
4566 continue;
4567 }
4568
4569 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
4570 1, section->sh_size,
4571 _("dynamic strings"));
4572 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
4573 }
4574 else if (section->sh_type == SHT_SYMTAB_SHNDX)
4575 {
4576 if (symtab_shndx_hdr != NULL)
4577 {
4578 error (_("File contains multiple symtab shndx tables\n"));
4579 continue;
4580 }
4581 symtab_shndx_hdr = section;
4582 }
4583 else if (section->sh_type == SHT_SYMTAB)
4584 CHECK_ENTSIZE (section, i, Sym);
4585 else if (section->sh_type == SHT_GROUP)
4586 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4587 else if (section->sh_type == SHT_REL)
4588 CHECK_ENTSIZE (section, i, Rel);
4589 else if (section->sh_type == SHT_RELA)
4590 CHECK_ENTSIZE (section, i, Rela);
4591 else if ((do_debugging || do_debug_info || do_debug_abbrevs
4592 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
4593 || do_debug_aranges || do_debug_frames || do_debug_macinfo
4594 || do_debug_str || do_debug_loc || do_debug_ranges)
4595 && (const_strneq (name, ".debug_")
4596 || const_strneq (name, ".zdebug_")))
4597 {
4598 if (name[1] == 'z')
4599 name += sizeof (".zdebug_") - 1;
4600 else
4601 name += sizeof (".debug_") - 1;
4602
4603 if (do_debugging
4604 || (do_debug_info && streq (name, "info"))
4605 || (do_debug_info && streq (name, "types"))
4606 || (do_debug_abbrevs && streq (name, "abbrev"))
4607 || (do_debug_lines && streq (name, "line"))
4608 || (do_debug_pubnames && streq (name, "pubnames"))
4609 || (do_debug_pubtypes && streq (name, "pubtypes"))
4610 || (do_debug_aranges && streq (name, "aranges"))
4611 || (do_debug_ranges && streq (name, "ranges"))
4612 || (do_debug_frames && streq (name, "frame"))
4613 || (do_debug_macinfo && streq (name, "macinfo"))
4614 || (do_debug_str && streq (name, "str"))
4615 || (do_debug_loc && streq (name, "loc"))
4616 )
4617 request_dump_bynumber (i, DEBUG_DUMP);
4618 }
4619 /* Linkonce section to be combined with .debug_info at link time. */
4620 else if ((do_debugging || do_debug_info)
4621 && const_strneq (name, ".gnu.linkonce.wi."))
4622 request_dump_bynumber (i, DEBUG_DUMP);
4623 else if (do_debug_frames && streq (name, ".eh_frame"))
4624 request_dump_bynumber (i, DEBUG_DUMP);
4625 else if (do_gdb_index && streq (name, ".gdb_index"))
4626 request_dump_bynumber (i, DEBUG_DUMP);
4627 /* Trace sections for Itanium VMS. */
4628 else if ((do_debugging || do_trace_info || do_trace_abbrevs
4629 || do_trace_aranges)
4630 && const_strneq (name, ".trace_"))
4631 {
4632 name += sizeof (".trace_") - 1;
4633
4634 if (do_debugging
4635 || (do_trace_info && streq (name, "info"))
4636 || (do_trace_abbrevs && streq (name, "abbrev"))
4637 || (do_trace_aranges && streq (name, "aranges"))
4638 )
4639 request_dump_bynumber (i, DEBUG_DUMP);
4640 }
4641
4642 }
4643
4644 if (! do_sections)
4645 return 1;
4646
4647 if (elf_header.e_shnum > 1)
4648 printf (_("\nSection Headers:\n"));
4649 else
4650 printf (_("\nSection Header:\n"));
4651
4652 if (is_32bit_elf)
4653 {
4654 if (do_section_details)
4655 {
4656 printf (_(" [Nr] Name\n"));
4657 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4658 }
4659 else
4660 printf
4661 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4662 }
4663 else if (do_wide)
4664 {
4665 if (do_section_details)
4666 {
4667 printf (_(" [Nr] Name\n"));
4668 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4669 }
4670 else
4671 printf
4672 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4673 }
4674 else
4675 {
4676 if (do_section_details)
4677 {
4678 printf (_(" [Nr] Name\n"));
4679 printf (_(" Type Address Offset Link\n"));
4680 printf (_(" Size EntSize Info Align\n"));
4681 }
4682 else
4683 {
4684 printf (_(" [Nr] Name Type Address Offset\n"));
4685 printf (_(" Size EntSize Flags Link Info Align\n"));
4686 }
4687 }
4688
4689 if (do_section_details)
4690 printf (_(" Flags\n"));
4691
4692 for (i = 0, section = section_headers;
4693 i < elf_header.e_shnum;
4694 i++, section++)
4695 {
4696 if (do_section_details)
4697 {
4698 printf (" [%2u] %s\n",
4699 i,
4700 SECTION_NAME (section));
4701 if (is_32bit_elf || do_wide)
4702 printf (" %-15.15s ",
4703 get_section_type_name (section->sh_type));
4704 }
4705 else
4706 printf ((do_wide ? " [%2u] %-17s %-15s "
4707 : " [%2u] %-17.17s %-15.15s "),
4708 i,
4709 SECTION_NAME (section),
4710 get_section_type_name (section->sh_type));
4711
4712 if (is_32bit_elf)
4713 {
4714 const char * link_too_big = NULL;
4715
4716 print_vma (section->sh_addr, LONG_HEX);
4717
4718 printf ( " %6.6lx %6.6lx %2.2lx",
4719 (unsigned long) section->sh_offset,
4720 (unsigned long) section->sh_size,
4721 (unsigned long) section->sh_entsize);
4722
4723 if (do_section_details)
4724 fputs (" ", stdout);
4725 else
4726 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4727
4728 if (section->sh_link >= elf_header.e_shnum)
4729 {
4730 link_too_big = "";
4731 /* The sh_link value is out of range. Normally this indicates
4732 an error but it can have special values in Solaris binaries. */
4733 switch (elf_header.e_machine)
4734 {
4735 case EM_386:
4736 case EM_486:
4737 case EM_X86_64:
4738 case EM_L1OM:
4739 case EM_OLD_SPARCV9:
4740 case EM_SPARC32PLUS:
4741 case EM_SPARCV9:
4742 case EM_SPARC:
4743 if (section->sh_link == (SHN_BEFORE & 0xffff))
4744 link_too_big = "BEFORE";
4745 else if (section->sh_link == (SHN_AFTER & 0xffff))
4746 link_too_big = "AFTER";
4747 break;
4748 default:
4749 break;
4750 }
4751 }
4752
4753 if (do_section_details)
4754 {
4755 if (link_too_big != NULL && * link_too_big)
4756 printf ("<%s> ", link_too_big);
4757 else
4758 printf ("%2u ", section->sh_link);
4759 printf ("%3u %2lu\n", section->sh_info,
4760 (unsigned long) section->sh_addralign);
4761 }
4762 else
4763 printf ("%2u %3u %2lu\n",
4764 section->sh_link,
4765 section->sh_info,
4766 (unsigned long) section->sh_addralign);
4767
4768 if (link_too_big && ! * link_too_big)
4769 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4770 i, section->sh_link);
4771 }
4772 else if (do_wide)
4773 {
4774 print_vma (section->sh_addr, LONG_HEX);
4775
4776 if ((long) section->sh_offset == section->sh_offset)
4777 printf (" %6.6lx", (unsigned long) section->sh_offset);
4778 else
4779 {
4780 putchar (' ');
4781 print_vma (section->sh_offset, LONG_HEX);
4782 }
4783
4784 if ((unsigned long) section->sh_size == section->sh_size)
4785 printf (" %6.6lx", (unsigned long) section->sh_size);
4786 else
4787 {
4788 putchar (' ');
4789 print_vma (section->sh_size, LONG_HEX);
4790 }
4791
4792 if ((unsigned long) section->sh_entsize == section->sh_entsize)
4793 printf (" %2.2lx", (unsigned long) section->sh_entsize);
4794 else
4795 {
4796 putchar (' ');
4797 print_vma (section->sh_entsize, LONG_HEX);
4798 }
4799
4800 if (do_section_details)
4801 fputs (" ", stdout);
4802 else
4803 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4804
4805 printf ("%2u %3u ", section->sh_link, section->sh_info);
4806
4807 if ((unsigned long) section->sh_addralign == section->sh_addralign)
4808 printf ("%2lu\n", (unsigned long) section->sh_addralign);
4809 else
4810 {
4811 print_vma (section->sh_addralign, DEC);
4812 putchar ('\n');
4813 }
4814 }
4815 else if (do_section_details)
4816 {
4817 printf (" %-15.15s ",
4818 get_section_type_name (section->sh_type));
4819 print_vma (section->sh_addr, LONG_HEX);
4820 if ((long) section->sh_offset == section->sh_offset)
4821 printf (" %16.16lx", (unsigned long) section->sh_offset);
4822 else
4823 {
4824 printf (" ");
4825 print_vma (section->sh_offset, LONG_HEX);
4826 }
4827 printf (" %u\n ", section->sh_link);
4828 print_vma (section->sh_size, LONG_HEX);
4829 putchar (' ');
4830 print_vma (section->sh_entsize, LONG_HEX);
4831
4832 printf (" %-16u %lu\n",
4833 section->sh_info,
4834 (unsigned long) section->sh_addralign);
4835 }
4836 else
4837 {
4838 putchar (' ');
4839 print_vma (section->sh_addr, LONG_HEX);
4840 if ((long) section->sh_offset == section->sh_offset)
4841 printf (" %8.8lx", (unsigned long) section->sh_offset);
4842 else
4843 {
4844 printf (" ");
4845 print_vma (section->sh_offset, LONG_HEX);
4846 }
4847 printf ("\n ");
4848 print_vma (section->sh_size, LONG_HEX);
4849 printf (" ");
4850 print_vma (section->sh_entsize, LONG_HEX);
4851
4852 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4853
4854 printf (" %2u %3u %lu\n",
4855 section->sh_link,
4856 section->sh_info,
4857 (unsigned long) section->sh_addralign);
4858 }
4859
4860 if (do_section_details)
4861 printf (" %s\n", get_elf_section_flags (section->sh_flags));
4862 }
4863
4864 if (!do_section_details)
4865 {
4866 if (elf_header.e_machine == EM_X86_64
4867 || elf_header.e_machine == EM_L1OM)
4868 printf (_("Key to Flags:\n\
4869 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
4870 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
4871 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4872 else
4873 printf (_("Key to Flags:\n\
4874 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4875 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
4876 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4877 }
4878
4879 return 1;
4880 }
4881
4882 static const char *
4883 get_group_flags (unsigned int flags)
4884 {
4885 static char buff[32];
4886 switch (flags)
4887 {
4888 case 0:
4889 return "";
4890
4891 case GRP_COMDAT:
4892 return "COMDAT ";
4893
4894 default:
4895 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
4896 break;
4897 }
4898 return buff;
4899 }
4900
4901 static int
4902 process_section_groups (FILE * file)
4903 {
4904 Elf_Internal_Shdr * section;
4905 unsigned int i;
4906 struct group * group;
4907 Elf_Internal_Shdr * symtab_sec;
4908 Elf_Internal_Shdr * strtab_sec;
4909 Elf_Internal_Sym * symtab;
4910 char * strtab;
4911 size_t strtab_size;
4912
4913 /* Don't process section groups unless needed. */
4914 if (!do_unwind && !do_section_groups)
4915 return 1;
4916
4917 if (elf_header.e_shnum == 0)
4918 {
4919 if (do_section_groups)
4920 printf (_("\nThere are no sections to group in this file.\n"));
4921
4922 return 1;
4923 }
4924
4925 if (section_headers == NULL)
4926 {
4927 error (_("Section headers are not available!\n"));
4928 abort ();
4929 }
4930
4931 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
4932 sizeof (struct group *));
4933
4934 if (section_headers_groups == NULL)
4935 {
4936 error (_("Out of memory\n"));
4937 return 0;
4938 }
4939
4940 /* Scan the sections for the group section. */
4941 group_count = 0;
4942 for (i = 0, section = section_headers;
4943 i < elf_header.e_shnum;
4944 i++, section++)
4945 if (section->sh_type == SHT_GROUP)
4946 group_count++;
4947
4948 if (group_count == 0)
4949 {
4950 if (do_section_groups)
4951 printf (_("\nThere are no section groups in this file.\n"));
4952
4953 return 1;
4954 }
4955
4956 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
4957
4958 if (section_groups == NULL)
4959 {
4960 error (_("Out of memory\n"));
4961 return 0;
4962 }
4963
4964 symtab_sec = NULL;
4965 strtab_sec = NULL;
4966 symtab = NULL;
4967 strtab = NULL;
4968 strtab_size = 0;
4969 for (i = 0, section = section_headers, group = section_groups;
4970 i < elf_header.e_shnum;
4971 i++, section++)
4972 {
4973 if (section->sh_type == SHT_GROUP)
4974 {
4975 char * name = SECTION_NAME (section);
4976 char * group_name;
4977 unsigned char * start;
4978 unsigned char * indices;
4979 unsigned int entry, j, size;
4980 Elf_Internal_Shdr * sec;
4981 Elf_Internal_Sym * sym;
4982
4983 /* Get the symbol table. */
4984 if (section->sh_link >= elf_header.e_shnum
4985 || ((sec = section_headers + section->sh_link)->sh_type
4986 != SHT_SYMTAB))
4987 {
4988 error (_("Bad sh_link in group section `%s'\n"), name);
4989 continue;
4990 }
4991
4992 if (symtab_sec != sec)
4993 {
4994 symtab_sec = sec;
4995 if (symtab)
4996 free (symtab);
4997 symtab = GET_ELF_SYMBOLS (file, symtab_sec);
4998 }
4999
5000 if (symtab == NULL)
5001 {
5002 error (_("Corrupt header in group section `%s'\n"), name);
5003 continue;
5004 }
5005
5006 sym = symtab + section->sh_info;
5007
5008 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5009 {
5010 if (sym->st_shndx == 0
5011 || sym->st_shndx >= elf_header.e_shnum)
5012 {
5013 error (_("Bad sh_info in group section `%s'\n"), name);
5014 continue;
5015 }
5016
5017 group_name = SECTION_NAME (section_headers + sym->st_shndx);
5018 strtab_sec = NULL;
5019 if (strtab)
5020 free (strtab);
5021 strtab = NULL;
5022 strtab_size = 0;
5023 }
5024 else
5025 {
5026 /* Get the string table. */
5027 if (symtab_sec->sh_link >= elf_header.e_shnum)
5028 {
5029 strtab_sec = NULL;
5030 if (strtab)
5031 free (strtab);
5032 strtab = NULL;
5033 strtab_size = 0;
5034 }
5035 else if (strtab_sec
5036 != (sec = section_headers + symtab_sec->sh_link))
5037 {
5038 strtab_sec = sec;
5039 if (strtab)
5040 free (strtab);
5041 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5042 1, strtab_sec->sh_size,
5043 _("string table"));
5044 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
5045 }
5046 group_name = sym->st_name < strtab_size
5047 ? strtab + sym->st_name : _("<corrupt>");
5048 }
5049
5050 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5051 1, section->sh_size,
5052 _("section data"));
5053 if (start == NULL)
5054 continue;
5055
5056 indices = start;
5057 size = (section->sh_size / section->sh_entsize) - 1;
5058 entry = byte_get (indices, 4);
5059 indices += 4;
5060
5061 if (do_section_groups)
5062 {
5063 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5064 get_group_flags (entry), i, name, group_name, size);
5065
5066 printf (_(" [Index] Name\n"));
5067 }
5068
5069 group->group_index = i;
5070
5071 for (j = 0; j < size; j++)
5072 {
5073 struct group_list * g;
5074
5075 entry = byte_get (indices, 4);
5076 indices += 4;
5077
5078 if (entry >= elf_header.e_shnum)
5079 {
5080 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5081 entry, i, elf_header.e_shnum - 1);
5082 continue;
5083 }
5084
5085 if (section_headers_groups [entry] != NULL)
5086 {
5087 if (entry)
5088 {
5089 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5090 entry, i,
5091 section_headers_groups [entry]->group_index);
5092 continue;
5093 }
5094 else
5095 {
5096 /* Intel C/C++ compiler may put section 0 in a
5097 section group. We just warn it the first time
5098 and ignore it afterwards. */
5099 static int warned = 0;
5100 if (!warned)
5101 {
5102 error (_("section 0 in group section [%5u]\n"),
5103 section_headers_groups [entry]->group_index);
5104 warned++;
5105 }
5106 }
5107 }
5108
5109 section_headers_groups [entry] = group;
5110
5111 if (do_section_groups)
5112 {
5113 sec = section_headers + entry;
5114 printf (" [%5u] %s\n", entry, SECTION_NAME (sec));
5115 }
5116
5117 g = (struct group_list *) xmalloc (sizeof (struct group_list));
5118 g->section_index = entry;
5119 g->next = group->root;
5120 group->root = g;
5121 }
5122
5123 if (start)
5124 free (start);
5125
5126 group++;
5127 }
5128 }
5129
5130 if (symtab)
5131 free (symtab);
5132 if (strtab)
5133 free (strtab);
5134 return 1;
5135 }
5136
5137 /* Data used to display dynamic fixups. */
5138
5139 struct ia64_vms_dynfixup
5140 {
5141 bfd_vma needed_ident; /* Library ident number. */
5142 bfd_vma needed; /* Index in the dstrtab of the library name. */
5143 bfd_vma fixup_needed; /* Index of the library. */
5144 bfd_vma fixup_rela_cnt; /* Number of fixups. */
5145 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
5146 };
5147
5148 /* Data used to display dynamic relocations. */
5149
5150 struct ia64_vms_dynimgrela
5151 {
5152 bfd_vma img_rela_cnt; /* Number of relocations. */
5153 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
5154 };
5155
5156 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5157 library). */
5158
5159 static void
5160 dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5161 const char *strtab, unsigned int strtab_sz)
5162 {
5163 Elf64_External_VMS_IMAGE_FIXUP *imfs;
5164 long i;
5165 const char *lib_name;
5166
5167 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5168 1, fixup->fixup_rela_cnt * sizeof (*imfs),
5169 _("dynamic section image fixups"));
5170 if (!imfs)
5171 return;
5172
5173 if (fixup->needed < strtab_sz)
5174 lib_name = strtab + fixup->needed;
5175 else
5176 {
5177 warn ("corrupt library name index of 0x%lx found in dynamic entry",
5178 (unsigned long) fixup->needed);
5179 lib_name = "???";
5180 }
5181 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5182 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5183 printf
5184 (_("Seg Offset Type SymVec DataType\n"));
5185
5186 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5187 {
5188 unsigned int type;
5189 const char *rtype;
5190
5191 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5192 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5193 type = BYTE_GET (imfs [i].type);
5194 rtype = elf_ia64_reloc_type (type);
5195 if (rtype == NULL)
5196 printf (" 0x%08x ", type);
5197 else
5198 printf (" %-32s ", rtype);
5199 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5200 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5201 }
5202
5203 free (imfs);
5204 }
5205
5206 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5207
5208 static void
5209 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5210 {
5211 Elf64_External_VMS_IMAGE_RELA *imrs;
5212 long i;
5213
5214 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5215 1, imgrela->img_rela_cnt * sizeof (*imrs),
5216 _("dynamic section image relas"));
5217 if (!imrs)
5218 return;
5219
5220 printf (_("\nImage relocs\n"));
5221 printf
5222 (_("Seg Offset Type Addend Seg Sym Off\n"));
5223
5224 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5225 {
5226 unsigned int type;
5227 const char *rtype;
5228
5229 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5230 printf ("%08" BFD_VMA_FMT "x ",
5231 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5232 type = BYTE_GET (imrs [i].type);
5233 rtype = elf_ia64_reloc_type (type);
5234 if (rtype == NULL)
5235 printf ("0x%08x ", type);
5236 else
5237 printf ("%-31s ", rtype);
5238 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5239 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5240 printf ("%08" BFD_VMA_FMT "x\n",
5241 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5242 }
5243
5244 free (imrs);
5245 }
5246
5247 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
5248
5249 static int
5250 process_ia64_vms_dynamic_relocs (FILE *file)
5251 {
5252 struct ia64_vms_dynfixup fixup;
5253 struct ia64_vms_dynimgrela imgrela;
5254 Elf_Internal_Dyn *entry;
5255 int res = 0;
5256 bfd_vma strtab_off = 0;
5257 bfd_vma strtab_sz = 0;
5258 char *strtab = NULL;
5259
5260 memset (&fixup, 0, sizeof (fixup));
5261 memset (&imgrela, 0, sizeof (imgrela));
5262
5263 /* Note: the order of the entries is specified by the OpenVMS specs. */
5264 for (entry = dynamic_section;
5265 entry < dynamic_section + dynamic_nent;
5266 entry++)
5267 {
5268 switch (entry->d_tag)
5269 {
5270 case DT_IA_64_VMS_STRTAB_OFFSET:
5271 strtab_off = entry->d_un.d_val;
5272 break;
5273 case DT_STRSZ:
5274 strtab_sz = entry->d_un.d_val;
5275 if (strtab == NULL)
5276 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5277 1, strtab_sz, _("dynamic string section"));
5278 break;
5279
5280 case DT_IA_64_VMS_NEEDED_IDENT:
5281 fixup.needed_ident = entry->d_un.d_val;
5282 break;
5283 case DT_NEEDED:
5284 fixup.needed = entry->d_un.d_val;
5285 break;
5286 case DT_IA_64_VMS_FIXUP_NEEDED:
5287 fixup.fixup_needed = entry->d_un.d_val;
5288 break;
5289 case DT_IA_64_VMS_FIXUP_RELA_CNT:
5290 fixup.fixup_rela_cnt = entry->d_un.d_val;
5291 break;
5292 case DT_IA_64_VMS_FIXUP_RELA_OFF:
5293 fixup.fixup_rela_off = entry->d_un.d_val;
5294 res++;
5295 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5296 break;
5297
5298 case DT_IA_64_VMS_IMG_RELA_CNT:
5299 imgrela.img_rela_cnt = entry->d_un.d_val;
5300 break;
5301 case DT_IA_64_VMS_IMG_RELA_OFF:
5302 imgrela.img_rela_off = entry->d_un.d_val;
5303 res++;
5304 dump_ia64_vms_dynamic_relocs (file, &imgrela);
5305 break;
5306
5307 default:
5308 break;
5309 }
5310 }
5311
5312 if (strtab != NULL)
5313 free (strtab);
5314
5315 return res;
5316 }
5317
5318 static struct
5319 {
5320 const char * name;
5321 int reloc;
5322 int size;
5323 int rela;
5324 } dynamic_relocations [] =
5325 {
5326 { "REL", DT_REL, DT_RELSZ, FALSE },
5327 { "RELA", DT_RELA, DT_RELASZ, TRUE },
5328 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5329 };
5330
5331 /* Process the reloc section. */
5332
5333 static int
5334 process_relocs (FILE * file)
5335 {
5336 unsigned long rel_size;
5337 unsigned long rel_offset;
5338
5339
5340 if (!do_reloc)
5341 return 1;
5342
5343 if (do_using_dynamic)
5344 {
5345 int is_rela;
5346 const char * name;
5347 int has_dynamic_reloc;
5348 unsigned int i;
5349
5350 has_dynamic_reloc = 0;
5351
5352 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
5353 {
5354 is_rela = dynamic_relocations [i].rela;
5355 name = dynamic_relocations [i].name;
5356 rel_size = dynamic_info [dynamic_relocations [i].size];
5357 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
5358
5359 has_dynamic_reloc |= rel_size;
5360
5361 if (is_rela == UNKNOWN)
5362 {
5363 if (dynamic_relocations [i].reloc == DT_JMPREL)
5364 switch (dynamic_info[DT_PLTREL])
5365 {
5366 case DT_REL:
5367 is_rela = FALSE;
5368 break;
5369 case DT_RELA:
5370 is_rela = TRUE;
5371 break;
5372 }
5373 }
5374
5375 if (rel_size)
5376 {
5377 printf
5378 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5379 name, rel_offset, rel_size);
5380
5381 dump_relocations (file,
5382 offset_from_vma (file, rel_offset, rel_size),
5383 rel_size,
5384 dynamic_symbols, num_dynamic_syms,
5385 dynamic_strings, dynamic_strings_length, is_rela);
5386 }
5387 }
5388
5389 if (is_ia64_vms ())
5390 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
5391
5392 if (! has_dynamic_reloc)
5393 printf (_("\nThere are no dynamic relocations in this file.\n"));
5394 }
5395 else
5396 {
5397 Elf_Internal_Shdr * section;
5398 unsigned long i;
5399 int found = 0;
5400
5401 for (i = 0, section = section_headers;
5402 i < elf_header.e_shnum;
5403 i++, section++)
5404 {
5405 if ( section->sh_type != SHT_RELA
5406 && section->sh_type != SHT_REL)
5407 continue;
5408
5409 rel_offset = section->sh_offset;
5410 rel_size = section->sh_size;
5411
5412 if (rel_size)
5413 {
5414 Elf_Internal_Shdr * strsec;
5415 int is_rela;
5416
5417 printf (_("\nRelocation section "));
5418
5419 if (string_table == NULL)
5420 printf ("%d", section->sh_name);
5421 else
5422 printf (_("'%s'"), SECTION_NAME (section));
5423
5424 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5425 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5426
5427 is_rela = section->sh_type == SHT_RELA;
5428
5429 if (section->sh_link != 0
5430 && section->sh_link < elf_header.e_shnum)
5431 {
5432 Elf_Internal_Shdr * symsec;
5433 Elf_Internal_Sym * symtab;
5434 unsigned long nsyms;
5435 unsigned long strtablen = 0;
5436 char * strtab = NULL;
5437
5438 symsec = section_headers + section->sh_link;
5439 if (symsec->sh_type != SHT_SYMTAB
5440 && symsec->sh_type != SHT_DYNSYM)
5441 continue;
5442
5443 nsyms = symsec->sh_size / symsec->sh_entsize;
5444 symtab = GET_ELF_SYMBOLS (file, symsec);
5445
5446 if (symtab == NULL)
5447 continue;
5448
5449 if (symsec->sh_link != 0
5450 && symsec->sh_link < elf_header.e_shnum)
5451 {
5452 strsec = section_headers + symsec->sh_link;
5453
5454 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5455 1, strsec->sh_size,
5456 _("string table"));
5457 strtablen = strtab == NULL ? 0 : strsec->sh_size;
5458 }
5459
5460 dump_relocations (file, rel_offset, rel_size,
5461 symtab, nsyms, strtab, strtablen, is_rela);
5462 if (strtab)
5463 free (strtab);
5464 free (symtab);
5465 }
5466 else
5467 dump_relocations (file, rel_offset, rel_size,
5468 NULL, 0, NULL, 0, is_rela);
5469
5470 found = 1;
5471 }
5472 }
5473
5474 if (! found)
5475 printf (_("\nThere are no relocations in this file.\n"));
5476 }
5477
5478 return 1;
5479 }
5480
5481 /* Process the unwind section. */
5482
5483 #include "unwind-ia64.h"
5484
5485 /* An absolute address consists of a section and an offset. If the
5486 section is NULL, the offset itself is the address, otherwise, the
5487 address equals to LOAD_ADDRESS(section) + offset. */
5488
5489 struct absaddr
5490 {
5491 unsigned short section;
5492 bfd_vma offset;
5493 };
5494
5495 #define ABSADDR(a) \
5496 ((a).section \
5497 ? section_headers [(a).section].sh_addr + (a).offset \
5498 : (a).offset)
5499
5500 struct ia64_unw_table_entry
5501 {
5502 struct absaddr start;
5503 struct absaddr end;
5504 struct absaddr info;
5505 };
5506
5507 struct ia64_unw_aux_info
5508 {
5509
5510 struct ia64_unw_table_entry *table; /* Unwind table. */
5511 unsigned long table_len; /* Length of unwind table. */
5512 unsigned char * info; /* Unwind info. */
5513 unsigned long info_size; /* Size of unwind info. */
5514 bfd_vma info_addr; /* starting address of unwind info. */
5515 bfd_vma seg_base; /* Starting address of segment. */
5516 Elf_Internal_Sym * symtab; /* The symbol table. */
5517 unsigned long nsyms; /* Number of symbols. */
5518 char * strtab; /* The string table. */
5519 unsigned long strtab_size; /* Size of string table. */
5520 };
5521
5522 static void
5523 find_symbol_for_address (Elf_Internal_Sym * symtab,
5524 unsigned long nsyms,
5525 const char * strtab,
5526 unsigned long strtab_size,
5527 struct absaddr addr,
5528 const char ** symname,
5529 bfd_vma * offset)
5530 {
5531 bfd_vma dist = 0x100000;
5532 Elf_Internal_Sym * sym;
5533 Elf_Internal_Sym * best = NULL;
5534 unsigned long i;
5535
5536 REMOVE_ARCH_BITS (addr.offset);
5537
5538 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
5539 {
5540 bfd_vma value = sym->st_value;
5541
5542 REMOVE_ARCH_BITS (value);
5543
5544 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
5545 && sym->st_name != 0
5546 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
5547 && addr.offset >= value
5548 && addr.offset - value < dist)
5549 {
5550 best = sym;
5551 dist = addr.offset - value;
5552 if (!dist)
5553 break;
5554 }
5555 }
5556 if (best)
5557 {
5558 *symname = (best->st_name >= strtab_size
5559 ? _("<corrupt>") : strtab + best->st_name);
5560 *offset = dist;
5561 return;
5562 }
5563 *symname = NULL;
5564 *offset = addr.offset;
5565 }
5566
5567 static void
5568 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
5569 {
5570 struct ia64_unw_table_entry * tp;
5571 int in_body;
5572
5573 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5574 {
5575 bfd_vma stamp;
5576 bfd_vma offset;
5577 const unsigned char * dp;
5578 const unsigned char * head;
5579 const char * procname;
5580
5581 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5582 aux->strtab_size, tp->start, &procname, &offset);
5583
5584 fputs ("\n<", stdout);
5585
5586 if (procname)
5587 {
5588 fputs (procname, stdout);
5589
5590 if (offset)
5591 printf ("+%lx", (unsigned long) offset);
5592 }
5593
5594 fputs (">: [", stdout);
5595 print_vma (tp->start.offset, PREFIX_HEX);
5596 fputc ('-', stdout);
5597 print_vma (tp->end.offset, PREFIX_HEX);
5598 printf ("], info at +0x%lx\n",
5599 (unsigned long) (tp->info.offset - aux->seg_base));
5600
5601 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
5602 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
5603
5604 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5605 (unsigned) UNW_VER (stamp),
5606 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
5607 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
5608 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
5609 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
5610
5611 if (UNW_VER (stamp) != 1)
5612 {
5613 printf (_("\tUnknown version.\n"));
5614 continue;
5615 }
5616
5617 in_body = 0;
5618 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
5619 dp = unw_decode (dp, in_body, & in_body);
5620 }
5621 }
5622
5623 static int
5624 slurp_ia64_unwind_table (FILE * file,
5625 struct ia64_unw_aux_info * aux,
5626 Elf_Internal_Shdr * sec)
5627 {
5628 unsigned long size, nrelas, i;
5629 Elf_Internal_Phdr * seg;
5630 struct ia64_unw_table_entry * tep;
5631 Elf_Internal_Shdr * relsec;
5632 Elf_Internal_Rela * rela;
5633 Elf_Internal_Rela * rp;
5634 unsigned char * table;
5635 unsigned char * tp;
5636 Elf_Internal_Sym * sym;
5637 const char * relname;
5638
5639 /* First, find the starting address of the segment that includes
5640 this section: */
5641
5642 if (elf_header.e_phnum)
5643 {
5644 if (! get_program_headers (file))
5645 return 0;
5646
5647 for (seg = program_headers;
5648 seg < program_headers + elf_header.e_phnum;
5649 ++seg)
5650 {
5651 if (seg->p_type != PT_LOAD)
5652 continue;
5653
5654 if (sec->sh_addr >= seg->p_vaddr
5655 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5656 {
5657 aux->seg_base = seg->p_vaddr;
5658 break;
5659 }
5660 }
5661 }
5662
5663 /* Second, build the unwind table from the contents of the unwind section: */
5664 size = sec->sh_size;
5665 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5666 _("unwind table"));
5667 if (!table)
5668 return 0;
5669
5670 aux->table = (struct ia64_unw_table_entry *)
5671 xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
5672 tep = aux->table;
5673 for (tp = table; tp < table + size; ++tep)
5674 {
5675 tep->start.section = SHN_UNDEF;
5676 tep->end.section = SHN_UNDEF;
5677 tep->info.section = SHN_UNDEF;
5678 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5679 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5680 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5681 tep->start.offset += aux->seg_base;
5682 tep->end.offset += aux->seg_base;
5683 tep->info.offset += aux->seg_base;
5684 }
5685 free (table);
5686
5687 /* Third, apply any relocations to the unwind table: */
5688 for (relsec = section_headers;
5689 relsec < section_headers + elf_header.e_shnum;
5690 ++relsec)
5691 {
5692 if (relsec->sh_type != SHT_RELA
5693 || relsec->sh_info >= elf_header.e_shnum
5694 || section_headers + relsec->sh_info != sec)
5695 continue;
5696
5697 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5698 & rela, & nrelas))
5699 return 0;
5700
5701 for (rp = rela; rp < rela + nrelas; ++rp)
5702 {
5703 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
5704 sym = aux->symtab + get_reloc_symindex (rp->r_info);
5705
5706 if (! const_strneq (relname, "R_IA64_SEGREL"))
5707 {
5708 warn (_("Skipping unexpected relocation type %s\n"), relname);
5709 continue;
5710 }
5711
5712 i = rp->r_offset / (3 * eh_addr_size);
5713
5714 switch (rp->r_offset/eh_addr_size % 3)
5715 {
5716 case 0:
5717 aux->table[i].start.section = sym->st_shndx;
5718 aux->table[i].start.offset = rp->r_addend + sym->st_value;
5719 break;
5720 case 1:
5721 aux->table[i].end.section = sym->st_shndx;
5722 aux->table[i].end.offset = rp->r_addend + sym->st_value;
5723 break;
5724 case 2:
5725 aux->table[i].info.section = sym->st_shndx;
5726 aux->table[i].info.offset = rp->r_addend + sym->st_value;
5727 break;
5728 default:
5729 break;
5730 }
5731 }
5732
5733 free (rela);
5734 }
5735
5736 aux->table_len = size / (3 * eh_addr_size);
5737 return 1;
5738 }
5739
5740 static int
5741 ia64_process_unwind (FILE * file)
5742 {
5743 Elf_Internal_Shdr * sec;
5744 Elf_Internal_Shdr * unwsec = NULL;
5745 Elf_Internal_Shdr * strsec;
5746 unsigned long i, unwcount = 0, unwstart = 0;
5747 struct ia64_unw_aux_info aux;
5748
5749 memset (& aux, 0, sizeof (aux));
5750
5751 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5752 {
5753 if (sec->sh_type == SHT_SYMTAB
5754 && sec->sh_link < elf_header.e_shnum)
5755 {
5756 aux.nsyms = sec->sh_size / sec->sh_entsize;
5757 aux.symtab = GET_ELF_SYMBOLS (file, sec);
5758
5759 strsec = section_headers + sec->sh_link;
5760 assert (aux.strtab == NULL);
5761 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5762 1, strsec->sh_size,
5763 _("string table"));
5764 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
5765 }
5766 else if (sec->sh_type == SHT_IA_64_UNWIND)
5767 unwcount++;
5768 }
5769
5770 if (!unwcount)
5771 printf (_("\nThere are no unwind sections in this file.\n"));
5772
5773 while (unwcount-- > 0)
5774 {
5775 char * suffix;
5776 size_t len, len2;
5777
5778 for (i = unwstart, sec = section_headers + unwstart;
5779 i < elf_header.e_shnum; ++i, ++sec)
5780 if (sec->sh_type == SHT_IA_64_UNWIND)
5781 {
5782 unwsec = sec;
5783 break;
5784 }
5785
5786 unwstart = i + 1;
5787 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
5788
5789 if ((unwsec->sh_flags & SHF_GROUP) != 0)
5790 {
5791 /* We need to find which section group it is in. */
5792 struct group_list * g = section_headers_groups [i]->root;
5793
5794 for (; g != NULL; g = g->next)
5795 {
5796 sec = section_headers + g->section_index;
5797
5798 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
5799 break;
5800 }
5801
5802 if (g == NULL)
5803 i = elf_header.e_shnum;
5804 }
5805 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
5806 {
5807 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5808 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
5809 suffix = SECTION_NAME (unwsec) + len;
5810 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5811 ++i, ++sec)
5812 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
5813 && streq (SECTION_NAME (sec) + len2, suffix))
5814 break;
5815 }
5816 else
5817 {
5818 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5819 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5820 len = sizeof (ELF_STRING_ia64_unwind) - 1;
5821 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
5822 suffix = "";
5823 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
5824 suffix = SECTION_NAME (unwsec) + len;
5825 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5826 ++i, ++sec)
5827 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
5828 && streq (SECTION_NAME (sec) + len2, suffix))
5829 break;
5830 }
5831
5832 if (i == elf_header.e_shnum)
5833 {
5834 printf (_("\nCould not find unwind info section for "));
5835
5836 if (string_table == NULL)
5837 printf ("%d", unwsec->sh_name);
5838 else
5839 printf (_("'%s'"), SECTION_NAME (unwsec));
5840 }
5841 else
5842 {
5843 aux.info_addr = sec->sh_addr;
5844 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
5845 sec->sh_size,
5846 _("unwind info"));
5847 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
5848
5849 printf (_("\nUnwind section "));
5850
5851 if (string_table == NULL)
5852 printf ("%d", unwsec->sh_name);
5853 else
5854 printf (_("'%s'"), SECTION_NAME (unwsec));
5855
5856 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5857 (unsigned long) unwsec->sh_offset,
5858 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
5859
5860 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
5861
5862 if (aux.table_len > 0)
5863 dump_ia64_unwind (& aux);
5864
5865 if (aux.table)
5866 free ((char *) aux.table);
5867 if (aux.info)
5868 free ((char *) aux.info);
5869 aux.table = NULL;
5870 aux.info = NULL;
5871 }
5872 }
5873
5874 if (aux.symtab)
5875 free (aux.symtab);
5876 if (aux.strtab)
5877 free ((char *) aux.strtab);
5878
5879 return 1;
5880 }
5881
5882 struct hppa_unw_table_entry
5883 {
5884 struct absaddr start;
5885 struct absaddr end;
5886 unsigned int Cannot_unwind:1; /* 0 */
5887 unsigned int Millicode:1; /* 1 */
5888 unsigned int Millicode_save_sr0:1; /* 2 */
5889 unsigned int Region_description:2; /* 3..4 */
5890 unsigned int reserved1:1; /* 5 */
5891 unsigned int Entry_SR:1; /* 6 */
5892 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
5893 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
5894 unsigned int Args_stored:1; /* 16 */
5895 unsigned int Variable_Frame:1; /* 17 */
5896 unsigned int Separate_Package_Body:1; /* 18 */
5897 unsigned int Frame_Extension_Millicode:1; /* 19 */
5898 unsigned int Stack_Overflow_Check:1; /* 20 */
5899 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
5900 unsigned int Ada_Region:1; /* 22 */
5901 unsigned int cxx_info:1; /* 23 */
5902 unsigned int cxx_try_catch:1; /* 24 */
5903 unsigned int sched_entry_seq:1; /* 25 */
5904 unsigned int reserved2:1; /* 26 */
5905 unsigned int Save_SP:1; /* 27 */
5906 unsigned int Save_RP:1; /* 28 */
5907 unsigned int Save_MRP_in_frame:1; /* 29 */
5908 unsigned int extn_ptr_defined:1; /* 30 */
5909 unsigned int Cleanup_defined:1; /* 31 */
5910
5911 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
5912 unsigned int HP_UX_interrupt_marker:1; /* 1 */
5913 unsigned int Large_frame:1; /* 2 */
5914 unsigned int Pseudo_SP_Set:1; /* 3 */
5915 unsigned int reserved4:1; /* 4 */
5916 unsigned int Total_frame_size:27; /* 5..31 */
5917 };
5918
5919 struct hppa_unw_aux_info
5920 {
5921 struct hppa_unw_table_entry *table; /* Unwind table. */
5922 unsigned long table_len; /* Length of unwind table. */
5923 bfd_vma seg_base; /* Starting address of segment. */
5924 Elf_Internal_Sym * symtab; /* The symbol table. */
5925 unsigned long nsyms; /* Number of symbols. */
5926 char * strtab; /* The string table. */
5927 unsigned long strtab_size; /* Size of string table. */
5928 };
5929
5930 static void
5931 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
5932 {
5933 struct hppa_unw_table_entry * tp;
5934
5935 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5936 {
5937 bfd_vma offset;
5938 const char * procname;
5939
5940 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5941 aux->strtab_size, tp->start, &procname,
5942 &offset);
5943
5944 fputs ("\n<", stdout);
5945
5946 if (procname)
5947 {
5948 fputs (procname, stdout);
5949
5950 if (offset)
5951 printf ("+%lx", (unsigned long) offset);
5952 }
5953
5954 fputs (">: [", stdout);
5955 print_vma (tp->start.offset, PREFIX_HEX);
5956 fputc ('-', stdout);
5957 print_vma (tp->end.offset, PREFIX_HEX);
5958 printf ("]\n\t");
5959
5960 #define PF(_m) if (tp->_m) printf (#_m " ");
5961 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5962 PF(Cannot_unwind);
5963 PF(Millicode);
5964 PF(Millicode_save_sr0);
5965 /* PV(Region_description); */
5966 PF(Entry_SR);
5967 PV(Entry_FR);
5968 PV(Entry_GR);
5969 PF(Args_stored);
5970 PF(Variable_Frame);
5971 PF(Separate_Package_Body);
5972 PF(Frame_Extension_Millicode);
5973 PF(Stack_Overflow_Check);
5974 PF(Two_Instruction_SP_Increment);
5975 PF(Ada_Region);
5976 PF(cxx_info);
5977 PF(cxx_try_catch);
5978 PF(sched_entry_seq);
5979 PF(Save_SP);
5980 PF(Save_RP);
5981 PF(Save_MRP_in_frame);
5982 PF(extn_ptr_defined);
5983 PF(Cleanup_defined);
5984 PF(MPE_XL_interrupt_marker);
5985 PF(HP_UX_interrupt_marker);
5986 PF(Large_frame);
5987 PF(Pseudo_SP_Set);
5988 PV(Total_frame_size);
5989 #undef PF
5990 #undef PV
5991 }
5992
5993 printf ("\n");
5994 }
5995
5996 static int
5997 slurp_hppa_unwind_table (FILE * file,
5998 struct hppa_unw_aux_info * aux,
5999 Elf_Internal_Shdr * sec)
6000 {
6001 unsigned long size, unw_ent_size, nentries, nrelas, i;
6002 Elf_Internal_Phdr * seg;
6003 struct hppa_unw_table_entry * tep;
6004 Elf_Internal_Shdr * relsec;
6005 Elf_Internal_Rela * rela;
6006 Elf_Internal_Rela * rp;
6007 unsigned char * table;
6008 unsigned char * tp;
6009 Elf_Internal_Sym * sym;
6010 const char * relname;
6011
6012 /* First, find the starting address of the segment that includes
6013 this section. */
6014
6015 if (elf_header.e_phnum)
6016 {
6017 if (! get_program_headers (file))
6018 return 0;
6019
6020 for (seg = program_headers;
6021 seg < program_headers + elf_header.e_phnum;
6022 ++seg)
6023 {
6024 if (seg->p_type != PT_LOAD)
6025 continue;
6026
6027 if (sec->sh_addr >= seg->p_vaddr
6028 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6029 {
6030 aux->seg_base = seg->p_vaddr;
6031 break;
6032 }
6033 }
6034 }
6035
6036 /* Second, build the unwind table from the contents of the unwind
6037 section. */
6038 size = sec->sh_size;
6039 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6040 _("unwind table"));
6041 if (!table)
6042 return 0;
6043
6044 unw_ent_size = 16;
6045 nentries = size / unw_ent_size;
6046 size = unw_ent_size * nentries;
6047
6048 tep = aux->table = (struct hppa_unw_table_entry *)
6049 xcmalloc (nentries, sizeof (aux->table[0]));
6050
6051 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
6052 {
6053 unsigned int tmp1, tmp2;
6054
6055 tep->start.section = SHN_UNDEF;
6056 tep->end.section = SHN_UNDEF;
6057
6058 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6059 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6060 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6061 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6062
6063 tep->start.offset += aux->seg_base;
6064 tep->end.offset += aux->seg_base;
6065
6066 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6067 tep->Millicode = (tmp1 >> 30) & 0x1;
6068 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6069 tep->Region_description = (tmp1 >> 27) & 0x3;
6070 tep->reserved1 = (tmp1 >> 26) & 0x1;
6071 tep->Entry_SR = (tmp1 >> 25) & 0x1;
6072 tep->Entry_FR = (tmp1 >> 21) & 0xf;
6073 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6074 tep->Args_stored = (tmp1 >> 15) & 0x1;
6075 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6076 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6077 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6078 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6079 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6080 tep->Ada_Region = (tmp1 >> 9) & 0x1;
6081 tep->cxx_info = (tmp1 >> 8) & 0x1;
6082 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6083 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6084 tep->reserved2 = (tmp1 >> 5) & 0x1;
6085 tep->Save_SP = (tmp1 >> 4) & 0x1;
6086 tep->Save_RP = (tmp1 >> 3) & 0x1;
6087 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6088 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6089 tep->Cleanup_defined = tmp1 & 0x1;
6090
6091 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6092 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6093 tep->Large_frame = (tmp2 >> 29) & 0x1;
6094 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6095 tep->reserved4 = (tmp2 >> 27) & 0x1;
6096 tep->Total_frame_size = tmp2 & 0x7ffffff;
6097 }
6098 free (table);
6099
6100 /* Third, apply any relocations to the unwind table. */
6101 for (relsec = section_headers;
6102 relsec < section_headers + elf_header.e_shnum;
6103 ++relsec)
6104 {
6105 if (relsec->sh_type != SHT_RELA
6106 || relsec->sh_info >= elf_header.e_shnum
6107 || section_headers + relsec->sh_info != sec)
6108 continue;
6109
6110 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6111 & rela, & nrelas))
6112 return 0;
6113
6114 for (rp = rela; rp < rela + nrelas; ++rp)
6115 {
6116 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6117 sym = aux->symtab + get_reloc_symindex (rp->r_info);
6118
6119 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
6120 if (! const_strneq (relname, "R_PARISC_SEGREL"))
6121 {
6122 warn (_("Skipping unexpected relocation type %s\n"), relname);
6123 continue;
6124 }
6125
6126 i = rp->r_offset / unw_ent_size;
6127
6128 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
6129 {
6130 case 0:
6131 aux->table[i].start.section = sym->st_shndx;
6132 aux->table[i].start.offset = sym->st_value + rp->r_addend;
6133 break;
6134 case 1:
6135 aux->table[i].end.section = sym->st_shndx;
6136 aux->table[i].end.offset = sym->st_value + rp->r_addend;
6137 break;
6138 default:
6139 break;
6140 }
6141 }
6142
6143 free (rela);
6144 }
6145
6146 aux->table_len = nentries;
6147
6148 return 1;
6149 }
6150
6151 static int
6152 hppa_process_unwind (FILE * file)
6153 {
6154 struct hppa_unw_aux_info aux;
6155 Elf_Internal_Shdr * unwsec = NULL;
6156 Elf_Internal_Shdr * strsec;
6157 Elf_Internal_Shdr * sec;
6158 unsigned long i;
6159
6160 memset (& aux, 0, sizeof (aux));
6161
6162 if (string_table == NULL)
6163 return 1;
6164
6165 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6166 {
6167 if (sec->sh_type == SHT_SYMTAB
6168 && sec->sh_link < elf_header.e_shnum)
6169 {
6170 aux.nsyms = sec->sh_size / sec->sh_entsize;
6171 aux.symtab = GET_ELF_SYMBOLS (file, sec);
6172
6173 strsec = section_headers + sec->sh_link;
6174 assert (aux.strtab == NULL);
6175 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6176 1, strsec->sh_size,
6177 _("string table"));
6178 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6179 }
6180 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6181 unwsec = sec;
6182 }
6183
6184 if (!unwsec)
6185 printf (_("\nThere are no unwind sections in this file.\n"));
6186
6187 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6188 {
6189 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6190 {
6191 printf (_("\nUnwind section "));
6192 printf (_("'%s'"), SECTION_NAME (sec));
6193
6194 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6195 (unsigned long) sec->sh_offset,
6196 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
6197
6198 slurp_hppa_unwind_table (file, &aux, sec);
6199 if (aux.table_len > 0)
6200 dump_hppa_unwind (&aux);
6201
6202 if (aux.table)
6203 free ((char *) aux.table);
6204 aux.table = NULL;
6205 }
6206 }
6207
6208 if (aux.symtab)
6209 free (aux.symtab);
6210 if (aux.strtab)
6211 free ((char *) aux.strtab);
6212
6213 return 1;
6214 }
6215
6216 struct arm_section
6217 {
6218 unsigned char *data;
6219
6220 Elf_Internal_Shdr *sec;
6221 Elf_Internal_Rela *rela;
6222 unsigned long nrelas;
6223 unsigned int rel_type;
6224
6225 Elf_Internal_Rela *next_rela;
6226 };
6227
6228 struct arm_unw_aux_info
6229 {
6230 FILE *file;
6231
6232 Elf_Internal_Sym *symtab; /* The symbol table. */
6233 unsigned long nsyms; /* Number of symbols. */
6234 char *strtab; /* The string table. */
6235 unsigned long strtab_size; /* Size of string table. */
6236 };
6237
6238 static const char *
6239 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6240 bfd_vma fn, struct absaddr addr)
6241 {
6242 const char *procname;
6243 bfd_vma sym_offset;
6244
6245 if (addr.section == SHN_UNDEF)
6246 addr.offset = fn;
6247
6248 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6249 aux->strtab_size, addr, &procname,
6250 &sym_offset);
6251
6252 print_vma (fn, PREFIX_HEX);
6253
6254 if (procname)
6255 {
6256 fputs (" <", stdout);
6257 fputs (procname, stdout);
6258
6259 if (sym_offset)
6260 printf ("+0x%lx", (unsigned long) sym_offset);
6261 fputc ('>', stdout);
6262 }
6263
6264 return procname;
6265 }
6266
6267 static void
6268 arm_free_section (struct arm_section *arm_sec)
6269 {
6270 if (arm_sec->data != NULL)
6271 free (arm_sec->data);
6272
6273 if (arm_sec->rela != NULL)
6274 free (arm_sec->rela);
6275 }
6276
6277 static int
6278 arm_section_get_word (struct arm_unw_aux_info *aux,
6279 struct arm_section *arm_sec,
6280 Elf_Internal_Shdr *sec, bfd_vma word_offset,
6281 unsigned int *wordp, struct absaddr *addr)
6282 {
6283 Elf_Internal_Rela *rp;
6284 Elf_Internal_Sym *sym;
6285 const char * relname;
6286 unsigned int word;
6287 bfd_boolean wrapped;
6288
6289 addr->section = SHN_UNDEF;
6290 addr->offset = 0;
6291
6292 if (sec != arm_sec->sec)
6293 {
6294 Elf_Internal_Shdr *relsec;
6295
6296 arm_free_section (arm_sec);
6297
6298 arm_sec->sec = sec;
6299 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6300 sec->sh_size, _("unwind data"));
6301 arm_sec->rela = NULL;
6302 arm_sec->nrelas = 0;
6303
6304 for (relsec = section_headers;
6305 relsec < section_headers + elf_header.e_shnum;
6306 ++relsec)
6307 {
6308 if (relsec->sh_info >= elf_header.e_shnum
6309 || section_headers + relsec->sh_info != sec)
6310 continue;
6311
6312 if (relsec->sh_type == SHT_REL)
6313 {
6314 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6315 relsec->sh_size,
6316 & arm_sec->rela, & arm_sec->nrelas))
6317 return 0;
6318 break;
6319 }
6320 else if (relsec->sh_type == SHT_RELA)
6321 {
6322 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6323 relsec->sh_size,
6324 & arm_sec->rela, & arm_sec->nrelas))
6325 return 0;
6326 break;
6327 }
6328 }
6329
6330 arm_sec->next_rela = arm_sec->rela;
6331 }
6332
6333 if (arm_sec->data == NULL)
6334 return 0;
6335
6336 word = byte_get (arm_sec->data + word_offset, 4);
6337
6338 wrapped = FALSE;
6339 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6340 {
6341 bfd_vma prelval, offset;
6342
6343 if (rp->r_offset > word_offset && !wrapped)
6344 {
6345 rp = arm_sec->rela;
6346 wrapped = TRUE;
6347 }
6348 if (rp->r_offset > word_offset)
6349 break;
6350
6351 if (rp->r_offset & 3)
6352 {
6353 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6354 (unsigned long) rp->r_offset);
6355 continue;
6356 }
6357
6358 if (rp->r_offset < word_offset)
6359 continue;
6360
6361 switch (elf_header.e_machine)
6362 {
6363 case EM_ARM:
6364 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6365 break;
6366
6367 case EM_TI_C6000:
6368 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
6369 break;
6370
6371 default:
6372 abort();
6373 }
6374
6375 if (streq (relname, "R_ARM_NONE")
6376 || streq (relname, "R_C6000_NONE"))
6377 continue;
6378
6379 if (!(streq (relname, "R_ARM_PREL31")
6380 || streq (relname, "R_C6000_PREL31")))
6381 {
6382 warn (_("Skipping unexpected relocation type %s\n"), relname);
6383 continue;
6384 }
6385
6386 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6387
6388 if (arm_sec->rel_type == SHT_REL)
6389 {
6390 offset = word & 0x7fffffff;
6391 if (offset & 0x40000000)
6392 offset |= ~ (bfd_vma) 0x7fffffff;
6393 }
6394 else
6395 offset = rp->r_addend;
6396
6397 offset += sym->st_value;
6398 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6399
6400 if (streq (relname, "R_C6000_PREL31"))
6401 prelval >>= 1;
6402
6403 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6404 addr->section = sym->st_shndx;
6405 addr->offset = offset;
6406 break;
6407 }
6408
6409 *wordp = word;
6410 arm_sec->next_rela = rp;
6411
6412 return 1;
6413 }
6414
6415 static const char *tic6x_unwind_regnames[16] = {
6416 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6417 "A14", "A13", "A12", "A11", "A10",
6418 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"};
6419
6420 static void
6421 decode_tic6x_unwind_regmask (unsigned int mask)
6422 {
6423 int i;
6424
6425 for (i = 12; mask; mask >>= 1, i--)
6426 {
6427 if (mask & 1)
6428 {
6429 fputs (tic6x_unwind_regnames[i], stdout);
6430 if (mask > 1)
6431 fputs (", ", stdout);
6432 }
6433 }
6434 }
6435
6436 #define ADVANCE \
6437 if (remaining == 0 && more_words) \
6438 { \
6439 data_offset += 4; \
6440 if (!arm_section_get_word (aux, data_arm_sec, data_sec, \
6441 data_offset, &word, &addr)) \
6442 return; \
6443 remaining = 4; \
6444 more_words--; \
6445 } \
6446
6447 #define GET_OP(OP) \
6448 ADVANCE; \
6449 if (remaining) \
6450 { \
6451 remaining--; \
6452 (OP) = word >> 24; \
6453 word <<= 8; \
6454 } \
6455 else \
6456 { \
6457 printf (_("[Truncated opcode]\n")); \
6458 return; \
6459 } \
6460 printf ("0x%02x ", OP)
6461
6462 static void
6463 decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
6464 unsigned int word, unsigned int remaining,
6465 unsigned int more_words,
6466 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6467 struct arm_section *data_arm_sec)
6468 {
6469 struct absaddr addr;
6470
6471 /* Decode the unwinding instructions. */
6472 while (1)
6473 {
6474 unsigned int op, op2;
6475
6476 ADVANCE;
6477 if (remaining == 0)
6478 break;
6479 remaining--;
6480 op = word >> 24;
6481 word <<= 8;
6482
6483 printf (" 0x%02x ", op);
6484
6485 if ((op & 0xc0) == 0x00)
6486 {
6487 int offset = ((op & 0x3f) << 2) + 4;
6488
6489 printf (" vsp = vsp + %d", offset);
6490 }
6491 else if ((op & 0xc0) == 0x40)
6492 {
6493 int offset = ((op & 0x3f) << 2) + 4;
6494
6495 printf (" vsp = vsp - %d", offset);
6496 }
6497 else if ((op & 0xf0) == 0x80)
6498 {
6499 GET_OP (op2);
6500 if (op == 0x80 && op2 == 0)
6501 printf (_("Refuse to unwind"));
6502 else
6503 {
6504 unsigned int mask = ((op & 0x0f) << 8) | op2;
6505 int first = 1;
6506 int i;
6507
6508 printf ("pop {");
6509 for (i = 0; i < 12; i++)
6510 if (mask & (1 << i))
6511 {
6512 if (first)
6513 first = 0;
6514 else
6515 printf (", ");
6516 printf ("r%d", 4 + i);
6517 }
6518 printf ("}");
6519 }
6520 }
6521 else if ((op & 0xf0) == 0x90)
6522 {
6523 if (op == 0x9d || op == 0x9f)
6524 printf (_(" [Reserved]"));
6525 else
6526 printf (" vsp = r%d", op & 0x0f);
6527 }
6528 else if ((op & 0xf0) == 0xa0)
6529 {
6530 int end = 4 + (op & 0x07);
6531 int first = 1;
6532 int i;
6533
6534 printf (" pop {");
6535 for (i = 4; i <= end; i++)
6536 {
6537 if (first)
6538 first = 0;
6539 else
6540 printf (", ");
6541 printf ("r%d", i);
6542 }
6543 if (op & 0x08)
6544 {
6545 if (first)
6546 printf (", ");
6547 printf ("r14");
6548 }
6549 printf ("}");
6550 }
6551 else if (op == 0xb0)
6552 printf (_(" finish"));
6553 else if (op == 0xb1)
6554 {
6555 GET_OP (op2);
6556 if (op2 == 0 || (op2 & 0xf0) != 0)
6557 printf (_("[Spare]"));
6558 else
6559 {
6560 unsigned int mask = op2 & 0x0f;
6561 int first = 1;
6562 int i;
6563
6564 printf ("pop {");
6565 for (i = 0; i < 12; i++)
6566 if (mask & (1 << i))
6567 {
6568 if (first)
6569 first = 0;
6570 else
6571 printf (", ");
6572 printf ("r%d", i);
6573 }
6574 printf ("}");
6575 }
6576 }
6577 else if (op == 0xb2)
6578 {
6579 unsigned char buf[9];
6580 unsigned int i, len;
6581 unsigned long offset;
6582
6583 for (i = 0; i < sizeof (buf); i++)
6584 {
6585 GET_OP (buf[i]);
6586 if ((buf[i] & 0x80) == 0)
6587 break;
6588 }
6589 assert (i < sizeof (buf));
6590 offset = read_uleb128 (buf, &len);
6591 assert (len == i + 1);
6592 offset = offset * 4 + 0x204;
6593 printf ("vsp = vsp + %ld", offset);
6594 }
6595 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
6596 {
6597 unsigned int first, last;
6598
6599 GET_OP (op2);
6600 first = op2 >> 4;
6601 last = op2 & 0x0f;
6602 if (op == 0xc8)
6603 first = first + 16;
6604 printf ("pop {D%d", first);
6605 if (last)
6606 printf ("-D%d", first + last);
6607 printf ("}");
6608 }
6609 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
6610 {
6611 unsigned int count = op & 0x07;
6612
6613 printf ("pop {D8");
6614 if (count)
6615 printf ("-D%d", 8 + count);
6616 printf ("}");
6617 }
6618 else if (op >= 0xc0 && op <= 0xc5)
6619 {
6620 unsigned int count = op & 0x07;
6621
6622 printf (" pop {wR10");
6623 if (count)
6624 printf ("-wR%d", 10 + count);
6625 printf ("}");
6626 }
6627 else if (op == 0xc6)
6628 {
6629 unsigned int first, last;
6630
6631 GET_OP (op2);
6632 first = op2 >> 4;
6633 last = op2 & 0x0f;
6634 printf ("pop {wR%d", first);
6635 if (last)
6636 printf ("-wR%d", first + last);
6637 printf ("}");
6638 }
6639 else if (op == 0xc7)
6640 {
6641 GET_OP (op2);
6642 if (op2 == 0 || (op2 & 0xf0) != 0)
6643 printf (_("[Spare]"));
6644 else
6645 {
6646 unsigned int mask = op2 & 0x0f;
6647 int first = 1;
6648 int i;
6649
6650 printf ("pop {");
6651 for (i = 0; i < 4; i++)
6652 if (mask & (1 << i))
6653 {
6654 if (first)
6655 first = 0;
6656 else
6657 printf (", ");
6658 printf ("wCGR%d", i);
6659 }
6660 printf ("}");
6661 }
6662 }
6663 else
6664 printf (_(" [unsupported opcode]"));
6665 printf ("\n");
6666 }
6667 }
6668
6669 static void
6670 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
6671 unsigned int word, unsigned int remaining,
6672 unsigned int more_words,
6673 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6674 struct arm_section *data_arm_sec)
6675 {
6676 struct absaddr addr;
6677
6678 /* Decode the unwinding instructions. */
6679 while (1)
6680 {
6681 unsigned int op, op2;
6682
6683 ADVANCE;
6684 if (remaining == 0)
6685 break;
6686 remaining--;
6687 op = word >> 24;
6688 word <<= 8;
6689
6690 printf (_(" 0x%02x "), op);
6691
6692 if ((op & 0xc0) == 0x00)
6693 {
6694 int offset = ((op & 0x3f) << 3) + 8;
6695 printf (_(" sp = sp + %d"), offset);
6696 }
6697 else if ((op & 0xc0) == 0x80)
6698 {
6699 GET_OP (op2);
6700 if (op == 0x80 && op2 == 0)
6701 printf (_("Refuse to unwind"));
6702 else
6703 {
6704 unsigned int mask = ((op & 0x1f) << 8) | op2;
6705 if (op & 0x20)
6706 printf ("pop compact {");
6707 else
6708 printf ("pop {");
6709
6710 decode_tic6x_unwind_regmask (mask);
6711 printf("}");
6712 }
6713 }
6714 else if ((op & 0xf0) == 0xc0)
6715 {
6716 unsigned int reg;
6717 unsigned int nregs;
6718 unsigned int i;
6719 const char *name;
6720 struct {
6721 unsigned int offset;
6722 unsigned int reg;
6723 } regpos[16];
6724
6725 /* Scan entire instruction first so that GET_OP output is not
6726 interleaved with disassembly. */
6727 nregs = 0;
6728 for (i = 0; nregs < (op & 0xf); i++)
6729 {
6730 GET_OP (op2);
6731 reg = op2 >> 4;
6732 if (reg != 0xf)
6733 {
6734 regpos[nregs].offset = i * 2;
6735 regpos[nregs].reg = reg;
6736 nregs++;
6737 }
6738
6739 reg = op2 & 0xf;
6740 if (reg != 0xf)
6741 {
6742 regpos[nregs].offset = i * 2 + 1;
6743 regpos[nregs].reg = reg;
6744 nregs++;
6745 }
6746 }
6747
6748 printf (_("pop frame {"));
6749 reg = nregs - 1;
6750 for (i = i * 2; i > 0; i--)
6751 {
6752 if (regpos[reg].offset == i - 1)
6753 {
6754 name = tic6x_unwind_regnames[regpos[reg].reg];
6755 if (reg > 0)
6756 reg--;
6757 }
6758 else
6759 name = _("[pad]");
6760
6761 fputs (name, stdout);
6762 if (i > 1)
6763 printf (", ");
6764 }
6765
6766 printf ("}");
6767 }
6768 else if (op == 0xd0)
6769 printf (" MOV FP, SP");
6770 else if (op == 0xd1)
6771 printf (" __c6xabi_pop_rts");
6772 else if (op == 0xd2)
6773 {
6774 unsigned char buf[9];
6775 unsigned int i, len;
6776 unsigned long offset;
6777 for (i = 0; i < sizeof (buf); i++)
6778 {
6779 GET_OP (buf[i]);
6780 if ((buf[i] & 0x80) == 0)
6781 break;
6782 }
6783 assert (i < sizeof (buf));
6784 offset = read_uleb128 (buf, &len);
6785 assert (len == i + 1);
6786 offset = offset * 8 + 0x408;
6787 printf (_("sp = sp + %ld"), offset);
6788 }
6789 else if ((op & 0xf0) == 0xe0)
6790 {
6791 if ((op & 0x0f) == 7)
6792 printf (" RETURN");
6793 else
6794 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
6795 }
6796 else
6797 {
6798 printf (_(" [unsupported opcode]"));
6799 }
6800 putchar ('\n');
6801 }
6802 }
6803
6804 static bfd_vma
6805 expand_prel31 (bfd_vma word, bfd_vma where)
6806 {
6807 bfd_vma offset;
6808
6809 offset = word & 0x7fffffff;
6810 if (offset & 0x40000000)
6811 offset |= ~ (bfd_vma) 0x7fffffff;
6812
6813 if (elf_header.e_machine == EM_TI_C6000)
6814 offset <<= 1;
6815
6816 return offset + where;
6817 }
6818
6819 static void
6820 decode_arm_unwind (struct arm_unw_aux_info *aux,
6821 unsigned int word, unsigned int remaining,
6822 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6823 struct arm_section *data_arm_sec)
6824 {
6825 int per_index;
6826 unsigned int more_words = 0;
6827 struct absaddr addr;
6828
6829 if (remaining == 0)
6830 {
6831 /* Fetch the first word. */
6832 if (!arm_section_get_word (aux, data_arm_sec, data_sec, data_offset,
6833 &word, &addr))
6834 return;
6835 remaining = 4;
6836 }
6837
6838 if ((word & 0x80000000) == 0)
6839 {
6840 /* Expand prel31 for personality routine. */
6841 bfd_vma fn;
6842 const char *procname;
6843
6844 fn = expand_prel31 (word, data_sec->sh_addr + data_offset);
6845 printf (_(" Personality routine: "));
6846 procname = arm_print_vma_and_name (aux, fn, addr);
6847 fputc ('\n', stdout);
6848
6849 /* The GCC personality routines use the standard compact
6850 encoding, starting with one byte giving the number of
6851 words. */
6852 if (procname != NULL
6853 && (const_strneq (procname, "__gcc_personality_v0")
6854 || const_strneq (procname, "__gxx_personality_v0")
6855 || const_strneq (procname, "__gcj_personality_v0")
6856 || const_strneq (procname, "__gnu_objc_personality_v0")))
6857 {
6858 remaining = 0;
6859 more_words = 1;
6860 ADVANCE;
6861 if (!remaining)
6862 {
6863 printf (_(" [Truncated data]\n"));
6864 return;
6865 }
6866 more_words = word >> 24;
6867 word <<= 8;
6868 remaining--;
6869 per_index = -1;
6870 }
6871 else
6872 return;
6873 }
6874 else
6875 {
6876
6877 per_index = (word >> 24) & 0x7f;
6878 printf (_(" Compact model %d\n"), per_index);
6879 if (per_index == 0)
6880 {
6881 more_words = 0;
6882 word <<= 8;
6883 remaining--;
6884 }
6885 else if (per_index < 3)
6886 {
6887 more_words = (word >> 16) & 0xff;
6888 word <<= 16;
6889 remaining -= 2;
6890 }
6891 }
6892
6893 switch (elf_header.e_machine)
6894 {
6895 case EM_ARM:
6896 if (per_index < 3)
6897 {
6898 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
6899 data_offset, data_sec, data_arm_sec);
6900 }
6901 else
6902 printf (" [reserved]\n");
6903 break;
6904
6905 case EM_TI_C6000:
6906 if (per_index < 3)
6907 {
6908 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
6909 data_offset, data_sec, data_arm_sec);
6910 }
6911 else if (per_index < 5)
6912 {
6913 if (((word >> 17) & 0x7f) == 0x7f)
6914 printf (_(" Restore stack from frame pointer\n"));
6915 else
6916 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
6917 printf (_(" Registers restored: "));
6918 if (per_index == 4)
6919 printf (" (compact) ");
6920 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
6921 putchar ('\n');
6922 printf (_(" Return register: %s\n"),
6923 tic6x_unwind_regnames[word & 0xf]);
6924 }
6925 else
6926 printf (" [reserved]\n");
6927 break;
6928
6929 default:
6930 abort ();
6931 }
6932
6933 /* Decode the descriptors. Not implemented. */
6934 }
6935
6936 static void
6937 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
6938 {
6939 struct arm_section exidx_arm_sec, extab_arm_sec;
6940 unsigned int i, exidx_len;
6941
6942 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
6943 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
6944 exidx_len = exidx_sec->sh_size / 8;
6945
6946 for (i = 0; i < exidx_len; i++)
6947 {
6948 unsigned int exidx_fn, exidx_entry;
6949 struct absaddr fn_addr, entry_addr;
6950 bfd_vma fn;
6951
6952 fputc ('\n', stdout);
6953
6954 if (!arm_section_get_word (aux, &exidx_arm_sec, exidx_sec,
6955 8 * i, &exidx_fn, &fn_addr)
6956 || !arm_section_get_word (aux, &exidx_arm_sec, exidx_sec,
6957 8 * i + 4, &exidx_entry, &entry_addr))
6958 {
6959 arm_free_section (&exidx_arm_sec);
6960 arm_free_section (&extab_arm_sec);
6961 return;
6962 }
6963
6964 fn = expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
6965
6966 arm_print_vma_and_name (aux, fn, entry_addr);
6967 fputs (": ", stdout);
6968
6969 if (exidx_entry == 1)
6970 {
6971 print_vma (exidx_entry, PREFIX_HEX);
6972 fputs (" [cantunwind]\n", stdout);
6973 }
6974 else if (exidx_entry & 0x80000000)
6975 {
6976 print_vma (exidx_entry, PREFIX_HEX);
6977 fputc ('\n', stdout);
6978 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
6979 }
6980 else
6981 {
6982 bfd_vma table, table_offset = 0;
6983 Elf_Internal_Shdr *table_sec;
6984
6985 fputs ("@", stdout);
6986 table = expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
6987 print_vma (table, PREFIX_HEX);
6988 printf ("\n");
6989
6990 /* Locate the matching .ARM.extab. */
6991 if (entry_addr.section != SHN_UNDEF
6992 && entry_addr.section < elf_header.e_shnum)
6993 {
6994 table_sec = section_headers + entry_addr.section;
6995 table_offset = entry_addr.offset;
6996 }
6997 else
6998 {
6999 table_sec = find_section_by_address (table);
7000 if (table_sec != NULL)
7001 table_offset = table - table_sec->sh_addr;
7002 }
7003 if (table_sec == NULL)
7004 {
7005 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7006 (unsigned long) table);
7007 continue;
7008 }
7009 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7010 &extab_arm_sec);
7011 }
7012 }
7013
7014 printf ("\n");
7015
7016 arm_free_section (&exidx_arm_sec);
7017 arm_free_section (&extab_arm_sec);
7018 }
7019
7020 /* Used for both ARM and C6X unwinding tables. */
7021 static int
7022 arm_process_unwind (FILE *file)
7023 {
7024 struct arm_unw_aux_info aux;
7025 Elf_Internal_Shdr *unwsec = NULL;
7026 Elf_Internal_Shdr *strsec;
7027 Elf_Internal_Shdr *sec;
7028 unsigned long i;
7029 unsigned int sec_type;
7030
7031 memset (& aux, 0, sizeof (aux));
7032 aux.file = file;
7033
7034 switch (elf_header.e_machine)
7035 {
7036 case EM_ARM:
7037 sec_type = SHT_ARM_EXIDX;
7038 break;
7039
7040 case EM_TI_C6000:
7041 sec_type = SHT_C6000_UNWIND;
7042 break;
7043
7044 default:
7045 abort();
7046 }
7047
7048 if (string_table == NULL)
7049 return 1;
7050
7051 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7052 {
7053 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
7054 {
7055 aux.nsyms = sec->sh_size / sec->sh_entsize;
7056 aux.symtab = GET_ELF_SYMBOLS (file, sec);
7057
7058 strsec = section_headers + sec->sh_link;
7059 assert (aux.strtab == NULL);
7060 aux.strtab = get_data (NULL, file, strsec->sh_offset,
7061 1, strsec->sh_size, _("string table"));
7062 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7063 }
7064 else if (sec->sh_type == sec_type)
7065 unwsec = sec;
7066 }
7067
7068 if (!unwsec)
7069 printf (_("\nThere are no unwind sections in this file.\n"));
7070
7071 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7072 {
7073 if (sec->sh_type == sec_type)
7074 {
7075 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7076 SECTION_NAME (sec),
7077 (unsigned long) sec->sh_offset,
7078 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
7079
7080 dump_arm_unwind (&aux, sec);
7081 }
7082 }
7083
7084 if (aux.symtab)
7085 free (aux.symtab);
7086 if (aux.strtab)
7087 free ((char *) aux.strtab);
7088
7089 return 1;
7090 }
7091
7092 static int
7093 process_unwind (FILE * file)
7094 {
7095 struct unwind_handler
7096 {
7097 int machtype;
7098 int (* handler)(FILE *);
7099 } handlers[] =
7100 {
7101 { EM_ARM, arm_process_unwind },
7102 { EM_IA_64, ia64_process_unwind },
7103 { EM_PARISC, hppa_process_unwind },
7104 { EM_TI_C6000, arm_process_unwind },
7105 { 0, 0 }
7106 };
7107 int i;
7108
7109 if (!do_unwind)
7110 return 1;
7111
7112 for (i = 0; handlers[i].handler != NULL; i++)
7113 if (elf_header.e_machine == handlers[i].machtype)
7114 return handlers[i].handler (file);
7115
7116 printf (_("\nThere are no unwind sections in this file.\n"));
7117 return 1;
7118 }
7119
7120 static void
7121 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
7122 {
7123 switch (entry->d_tag)
7124 {
7125 case DT_MIPS_FLAGS:
7126 if (entry->d_un.d_val == 0)
7127 printf (_("NONE\n"));
7128 else
7129 {
7130 static const char * opts[] =
7131 {
7132 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7133 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7134 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7135 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7136 "RLD_ORDER_SAFE"
7137 };
7138 unsigned int cnt;
7139 int first = 1;
7140
7141 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
7142 if (entry->d_un.d_val & (1 << cnt))
7143 {
7144 printf ("%s%s", first ? "" : " ", opts[cnt]);
7145 first = 0;
7146 }
7147 puts ("");
7148 }
7149 break;
7150
7151 case DT_MIPS_IVERSION:
7152 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7153 printf (_("Interface Version: %s\n"), GET_DYNAMIC_NAME (entry->d_un.d_val));
7154 else
7155 printf (_("<corrupt: %ld>\n"), (long) entry->d_un.d_ptr);
7156 break;
7157
7158 case DT_MIPS_TIME_STAMP:
7159 {
7160 char timebuf[20];
7161 struct tm * tmp;
7162
7163 time_t atime = entry->d_un.d_val;
7164 tmp = gmtime (&atime);
7165 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
7166 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7167 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7168 printf (_("Time Stamp: %s\n"), timebuf);
7169 }
7170 break;
7171
7172 case DT_MIPS_RLD_VERSION:
7173 case DT_MIPS_LOCAL_GOTNO:
7174 case DT_MIPS_CONFLICTNO:
7175 case DT_MIPS_LIBLISTNO:
7176 case DT_MIPS_SYMTABNO:
7177 case DT_MIPS_UNREFEXTNO:
7178 case DT_MIPS_HIPAGENO:
7179 case DT_MIPS_DELTA_CLASS_NO:
7180 case DT_MIPS_DELTA_INSTANCE_NO:
7181 case DT_MIPS_DELTA_RELOC_NO:
7182 case DT_MIPS_DELTA_SYM_NO:
7183 case DT_MIPS_DELTA_CLASSSYM_NO:
7184 case DT_MIPS_COMPACT_SIZE:
7185 printf ("%ld\n", (long) entry->d_un.d_ptr);
7186 break;
7187
7188 default:
7189 printf ("%#lx\n", (unsigned long) entry->d_un.d_ptr);
7190 }
7191 }
7192
7193 static void
7194 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
7195 {
7196 switch (entry->d_tag)
7197 {
7198 case DT_HP_DLD_FLAGS:
7199 {
7200 static struct
7201 {
7202 long int bit;
7203 const char * str;
7204 }
7205 flags[] =
7206 {
7207 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
7208 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
7209 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
7210 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
7211 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
7212 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
7213 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
7214 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
7215 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
7216 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
7217 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
7218 { DT_HP_GST, "HP_GST" },
7219 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
7220 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
7221 { DT_HP_NODELETE, "HP_NODELETE" },
7222 { DT_HP_GROUP, "HP_GROUP" },
7223 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
7224 };
7225 int first = 1;
7226 size_t cnt;
7227 bfd_vma val = entry->d_un.d_val;
7228
7229 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
7230 if (val & flags[cnt].bit)
7231 {
7232 if (! first)
7233 putchar (' ');
7234 fputs (flags[cnt].str, stdout);
7235 first = 0;
7236 val ^= flags[cnt].bit;
7237 }
7238
7239 if (val != 0 || first)
7240 {
7241 if (! first)
7242 putchar (' ');
7243 print_vma (val, HEX);
7244 }
7245 }
7246 break;
7247
7248 default:
7249 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7250 break;
7251 }
7252 putchar ('\n');
7253 }
7254
7255 #ifdef BFD64
7256
7257 /* VMS vs Unix time offset and factor. */
7258
7259 #define VMS_EPOCH_OFFSET 35067168000000000LL
7260 #define VMS_GRANULARITY_FACTOR 10000000
7261
7262 /* Display a VMS time in a human readable format. */
7263
7264 static void
7265 print_vms_time (bfd_int64_t vmstime)
7266 {
7267 struct tm *tm;
7268 time_t unxtime;
7269
7270 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
7271 tm = gmtime (&unxtime);
7272 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7273 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
7274 tm->tm_hour, tm->tm_min, tm->tm_sec);
7275 }
7276 #endif /* BFD64 */
7277
7278 static void
7279 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
7280 {
7281 switch (entry->d_tag)
7282 {
7283 case DT_IA_64_PLT_RESERVE:
7284 /* First 3 slots reserved. */
7285 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7286 printf (" -- ");
7287 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
7288 break;
7289
7290 case DT_IA_64_VMS_LINKTIME:
7291 #ifdef BFD64
7292 print_vms_time (entry->d_un.d_val);
7293 #endif
7294 break;
7295
7296 case DT_IA_64_VMS_LNKFLAGS:
7297 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7298 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
7299 printf (" CALL_DEBUG");
7300 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
7301 printf (" NOP0BUFS");
7302 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
7303 printf (" P0IMAGE");
7304 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
7305 printf (" MKTHREADS");
7306 if (entry->d_un.d_val & VMS_LF_UPCALLS)
7307 printf (" UPCALLS");
7308 if (entry->d_un.d_val & VMS_LF_IMGSTA)
7309 printf (" IMGSTA");
7310 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
7311 printf (" INITIALIZE");
7312 if (entry->d_un.d_val & VMS_LF_MAIN)
7313 printf (" MAIN");
7314 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
7315 printf (" EXE_INIT");
7316 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
7317 printf (" TBK_IN_IMG");
7318 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
7319 printf (" DBG_IN_IMG");
7320 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
7321 printf (" TBK_IN_DSF");
7322 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
7323 printf (" DBG_IN_DSF");
7324 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
7325 printf (" SIGNATURES");
7326 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
7327 printf (" REL_SEG_OFF");
7328 break;
7329
7330 default:
7331 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7332 break;
7333 }
7334 putchar ('\n');
7335 }
7336
7337 static int
7338 get_32bit_dynamic_section (FILE * file)
7339 {
7340 Elf32_External_Dyn * edyn;
7341 Elf32_External_Dyn * ext;
7342 Elf_Internal_Dyn * entry;
7343
7344 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7345 dynamic_size, _("dynamic section"));
7346 if (!edyn)
7347 return 0;
7348
7349 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7350 might not have the luxury of section headers. Look for the DT_NULL
7351 terminator to determine the number of entries. */
7352 for (ext = edyn, dynamic_nent = 0;
7353 (char *) ext < (char *) edyn + dynamic_size;
7354 ext++)
7355 {
7356 dynamic_nent++;
7357 if (BYTE_GET (ext->d_tag) == DT_NULL)
7358 break;
7359 }
7360
7361 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7362 sizeof (* entry));
7363 if (dynamic_section == NULL)
7364 {
7365 error (_("Out of memory\n"));
7366 free (edyn);
7367 return 0;
7368 }
7369
7370 for (ext = edyn, entry = dynamic_section;
7371 entry < dynamic_section + dynamic_nent;
7372 ext++, entry++)
7373 {
7374 entry->d_tag = BYTE_GET (ext->d_tag);
7375 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
7376 }
7377
7378 free (edyn);
7379
7380 return 1;
7381 }
7382
7383 static int
7384 get_64bit_dynamic_section (FILE * file)
7385 {
7386 Elf64_External_Dyn * edyn;
7387 Elf64_External_Dyn * ext;
7388 Elf_Internal_Dyn * entry;
7389
7390 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7391 dynamic_size, _("dynamic section"));
7392 if (!edyn)
7393 return 0;
7394
7395 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7396 might not have the luxury of section headers. Look for the DT_NULL
7397 terminator to determine the number of entries. */
7398 for (ext = edyn, dynamic_nent = 0;
7399 (char *) ext < (char *) edyn + dynamic_size;
7400 ext++)
7401 {
7402 dynamic_nent++;
7403 if (BYTE_GET (ext->d_tag) == DT_NULL)
7404 break;
7405 }
7406
7407 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7408 sizeof (* entry));
7409 if (dynamic_section == NULL)
7410 {
7411 error (_("Out of memory\n"));
7412 free (edyn);
7413 return 0;
7414 }
7415
7416 for (ext = edyn, entry = dynamic_section;
7417 entry < dynamic_section + dynamic_nent;
7418 ext++, entry++)
7419 {
7420 entry->d_tag = BYTE_GET (ext->d_tag);
7421 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
7422 }
7423
7424 free (edyn);
7425
7426 return 1;
7427 }
7428
7429 static void
7430 print_dynamic_flags (bfd_vma flags)
7431 {
7432 int first = 1;
7433
7434 while (flags)
7435 {
7436 bfd_vma flag;
7437
7438 flag = flags & - flags;
7439 flags &= ~ flag;
7440
7441 if (first)
7442 first = 0;
7443 else
7444 putc (' ', stdout);
7445
7446 switch (flag)
7447 {
7448 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
7449 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
7450 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
7451 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
7452 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
7453 default: fputs (_("unknown"), stdout); break;
7454 }
7455 }
7456 puts ("");
7457 }
7458
7459 /* Parse and display the contents of the dynamic section. */
7460
7461 static int
7462 process_dynamic_section (FILE * file)
7463 {
7464 Elf_Internal_Dyn * entry;
7465
7466 if (dynamic_size == 0)
7467 {
7468 if (do_dynamic)
7469 printf (_("\nThere is no dynamic section in this file.\n"));
7470
7471 return 1;
7472 }
7473
7474 if (is_32bit_elf)
7475 {
7476 if (! get_32bit_dynamic_section (file))
7477 return 0;
7478 }
7479 else if (! get_64bit_dynamic_section (file))
7480 return 0;
7481
7482 /* Find the appropriate symbol table. */
7483 if (dynamic_symbols == NULL)
7484 {
7485 for (entry = dynamic_section;
7486 entry < dynamic_section + dynamic_nent;
7487 ++entry)
7488 {
7489 Elf_Internal_Shdr section;
7490
7491 if (entry->d_tag != DT_SYMTAB)
7492 continue;
7493
7494 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
7495
7496 /* Since we do not know how big the symbol table is,
7497 we default to reading in the entire file (!) and
7498 processing that. This is overkill, I know, but it
7499 should work. */
7500 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
7501
7502 if (archive_file_offset != 0)
7503 section.sh_size = archive_file_size - section.sh_offset;
7504 else
7505 {
7506 if (fseek (file, 0, SEEK_END))
7507 error (_("Unable to seek to end of file!\n"));
7508
7509 section.sh_size = ftell (file) - section.sh_offset;
7510 }
7511
7512 if (is_32bit_elf)
7513 section.sh_entsize = sizeof (Elf32_External_Sym);
7514 else
7515 section.sh_entsize = sizeof (Elf64_External_Sym);
7516
7517 num_dynamic_syms = section.sh_size / section.sh_entsize;
7518 if (num_dynamic_syms < 1)
7519 {
7520 error (_("Unable to determine the number of symbols to load\n"));
7521 continue;
7522 }
7523
7524 dynamic_symbols = GET_ELF_SYMBOLS (file, &section);
7525 }
7526 }
7527
7528 /* Similarly find a string table. */
7529 if (dynamic_strings == NULL)
7530 {
7531 for (entry = dynamic_section;
7532 entry < dynamic_section + dynamic_nent;
7533 ++entry)
7534 {
7535 unsigned long offset;
7536 long str_tab_len;
7537
7538 if (entry->d_tag != DT_STRTAB)
7539 continue;
7540
7541 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
7542
7543 /* Since we do not know how big the string table is,
7544 we default to reading in the entire file (!) and
7545 processing that. This is overkill, I know, but it
7546 should work. */
7547
7548 offset = offset_from_vma (file, entry->d_un.d_val, 0);
7549
7550 if (archive_file_offset != 0)
7551 str_tab_len = archive_file_size - offset;
7552 else
7553 {
7554 if (fseek (file, 0, SEEK_END))
7555 error (_("Unable to seek to end of file\n"));
7556 str_tab_len = ftell (file) - offset;
7557 }
7558
7559 if (str_tab_len < 1)
7560 {
7561 error
7562 (_("Unable to determine the length of the dynamic string table\n"));
7563 continue;
7564 }
7565
7566 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
7567 str_tab_len,
7568 _("dynamic string table"));
7569 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
7570 break;
7571 }
7572 }
7573
7574 /* And find the syminfo section if available. */
7575 if (dynamic_syminfo == NULL)
7576 {
7577 unsigned long syminsz = 0;
7578
7579 for (entry = dynamic_section;
7580 entry < dynamic_section + dynamic_nent;
7581 ++entry)
7582 {
7583 if (entry->d_tag == DT_SYMINENT)
7584 {
7585 /* Note: these braces are necessary to avoid a syntax
7586 error from the SunOS4 C compiler. */
7587 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
7588 }
7589 else if (entry->d_tag == DT_SYMINSZ)
7590 syminsz = entry->d_un.d_val;
7591 else if (entry->d_tag == DT_SYMINFO)
7592 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
7593 syminsz);
7594 }
7595
7596 if (dynamic_syminfo_offset != 0 && syminsz != 0)
7597 {
7598 Elf_External_Syminfo * extsyminfo;
7599 Elf_External_Syminfo * extsym;
7600 Elf_Internal_Syminfo * syminfo;
7601
7602 /* There is a syminfo section. Read the data. */
7603 extsyminfo = (Elf_External_Syminfo *)
7604 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
7605 _("symbol information"));
7606 if (!extsyminfo)
7607 return 0;
7608
7609 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
7610 if (dynamic_syminfo == NULL)
7611 {
7612 error (_("Out of memory\n"));
7613 return 0;
7614 }
7615
7616 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
7617 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
7618 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
7619 ++syminfo, ++extsym)
7620 {
7621 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
7622 syminfo->si_flags = BYTE_GET (extsym->si_flags);
7623 }
7624
7625 free (extsyminfo);
7626 }
7627 }
7628
7629 if (do_dynamic && dynamic_addr)
7630 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
7631 dynamic_addr, dynamic_nent);
7632 if (do_dynamic)
7633 printf (_(" Tag Type Name/Value\n"));
7634
7635 for (entry = dynamic_section;
7636 entry < dynamic_section + dynamic_nent;
7637 entry++)
7638 {
7639 if (do_dynamic)
7640 {
7641 const char * dtype;
7642
7643 putchar (' ');
7644 print_vma (entry->d_tag, FULL_HEX);
7645 dtype = get_dynamic_type (entry->d_tag);
7646 printf (" (%s)%*s", dtype,
7647 ((is_32bit_elf ? 27 : 19)
7648 - (int) strlen (dtype)),
7649 " ");
7650 }
7651
7652 switch (entry->d_tag)
7653 {
7654 case DT_FLAGS:
7655 if (do_dynamic)
7656 print_dynamic_flags (entry->d_un.d_val);
7657 break;
7658
7659 case DT_AUXILIARY:
7660 case DT_FILTER:
7661 case DT_CONFIG:
7662 case DT_DEPAUDIT:
7663 case DT_AUDIT:
7664 if (do_dynamic)
7665 {
7666 switch (entry->d_tag)
7667 {
7668 case DT_AUXILIARY:
7669 printf (_("Auxiliary library"));
7670 break;
7671
7672 case DT_FILTER:
7673 printf (_("Filter library"));
7674 break;
7675
7676 case DT_CONFIG:
7677 printf (_("Configuration file"));
7678 break;
7679
7680 case DT_DEPAUDIT:
7681 printf (_("Dependency audit library"));
7682 break;
7683
7684 case DT_AUDIT:
7685 printf (_("Audit library"));
7686 break;
7687 }
7688
7689 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7690 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
7691 else
7692 {
7693 printf (": ");
7694 print_vma (entry->d_un.d_val, PREFIX_HEX);
7695 putchar ('\n');
7696 }
7697 }
7698 break;
7699
7700 case DT_FEATURE:
7701 if (do_dynamic)
7702 {
7703 printf (_("Flags:"));
7704
7705 if (entry->d_un.d_val == 0)
7706 printf (_(" None\n"));
7707 else
7708 {
7709 unsigned long int val = entry->d_un.d_val;
7710
7711 if (val & DTF_1_PARINIT)
7712 {
7713 printf (" PARINIT");
7714 val ^= DTF_1_PARINIT;
7715 }
7716 if (val & DTF_1_CONFEXP)
7717 {
7718 printf (" CONFEXP");
7719 val ^= DTF_1_CONFEXP;
7720 }
7721 if (val != 0)
7722 printf (" %lx", val);
7723 puts ("");
7724 }
7725 }
7726 break;
7727
7728 case DT_POSFLAG_1:
7729 if (do_dynamic)
7730 {
7731 printf (_("Flags:"));
7732
7733 if (entry->d_un.d_val == 0)
7734 printf (_(" None\n"));
7735 else
7736 {
7737 unsigned long int val = entry->d_un.d_val;
7738
7739 if (val & DF_P1_LAZYLOAD)
7740 {
7741 printf (" LAZYLOAD");
7742 val ^= DF_P1_LAZYLOAD;
7743 }
7744 if (val & DF_P1_GROUPPERM)
7745 {
7746 printf (" GROUPPERM");
7747 val ^= DF_P1_GROUPPERM;
7748 }
7749 if (val != 0)
7750 printf (" %lx", val);
7751 puts ("");
7752 }
7753 }
7754 break;
7755
7756 case DT_FLAGS_1:
7757 if (do_dynamic)
7758 {
7759 printf (_("Flags:"));
7760 if (entry->d_un.d_val == 0)
7761 printf (_(" None\n"));
7762 else
7763 {
7764 unsigned long int val = entry->d_un.d_val;
7765
7766 if (val & DF_1_NOW)
7767 {
7768 printf (" NOW");
7769 val ^= DF_1_NOW;
7770 }
7771 if (val & DF_1_GLOBAL)
7772 {
7773 printf (" GLOBAL");
7774 val ^= DF_1_GLOBAL;
7775 }
7776 if (val & DF_1_GROUP)
7777 {
7778 printf (" GROUP");
7779 val ^= DF_1_GROUP;
7780 }
7781 if (val & DF_1_NODELETE)
7782 {
7783 printf (" NODELETE");
7784 val ^= DF_1_NODELETE;
7785 }
7786 if (val & DF_1_LOADFLTR)
7787 {
7788 printf (" LOADFLTR");
7789 val ^= DF_1_LOADFLTR;
7790 }
7791 if (val & DF_1_INITFIRST)
7792 {
7793 printf (" INITFIRST");
7794 val ^= DF_1_INITFIRST;
7795 }
7796 if (val & DF_1_NOOPEN)
7797 {
7798 printf (" NOOPEN");
7799 val ^= DF_1_NOOPEN;
7800 }
7801 if (val & DF_1_ORIGIN)
7802 {
7803 printf (" ORIGIN");
7804 val ^= DF_1_ORIGIN;
7805 }
7806 if (val & DF_1_DIRECT)
7807 {
7808 printf (" DIRECT");
7809 val ^= DF_1_DIRECT;
7810 }
7811 if (val & DF_1_TRANS)
7812 {
7813 printf (" TRANS");
7814 val ^= DF_1_TRANS;
7815 }
7816 if (val & DF_1_INTERPOSE)
7817 {
7818 printf (" INTERPOSE");
7819 val ^= DF_1_INTERPOSE;
7820 }
7821 if (val & DF_1_NODEFLIB)
7822 {
7823 printf (" NODEFLIB");
7824 val ^= DF_1_NODEFLIB;
7825 }
7826 if (val & DF_1_NODUMP)
7827 {
7828 printf (" NODUMP");
7829 val ^= DF_1_NODUMP;
7830 }
7831 if (val & DF_1_CONLFAT)
7832 {
7833 printf (" CONLFAT");
7834 val ^= DF_1_CONLFAT;
7835 }
7836 if (val != 0)
7837 printf (" %lx", val);
7838 puts ("");
7839 }
7840 }
7841 break;
7842
7843 case DT_PLTREL:
7844 dynamic_info[entry->d_tag] = entry->d_un.d_val;
7845 if (do_dynamic)
7846 puts (get_dynamic_type (entry->d_un.d_val));
7847 break;
7848
7849 case DT_NULL :
7850 case DT_NEEDED :
7851 case DT_PLTGOT :
7852 case DT_HASH :
7853 case DT_STRTAB :
7854 case DT_SYMTAB :
7855 case DT_RELA :
7856 case DT_INIT :
7857 case DT_FINI :
7858 case DT_SONAME :
7859 case DT_RPATH :
7860 case DT_SYMBOLIC:
7861 case DT_REL :
7862 case DT_DEBUG :
7863 case DT_TEXTREL :
7864 case DT_JMPREL :
7865 case DT_RUNPATH :
7866 dynamic_info[entry->d_tag] = entry->d_un.d_val;
7867
7868 if (do_dynamic)
7869 {
7870 char * name;
7871
7872 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7873 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
7874 else
7875 name = NULL;
7876
7877 if (name)
7878 {
7879 switch (entry->d_tag)
7880 {
7881 case DT_NEEDED:
7882 printf (_("Shared library: [%s]"), name);
7883
7884 if (streq (name, program_interpreter))
7885 printf (_(" program interpreter"));
7886 break;
7887
7888 case DT_SONAME:
7889 printf (_("Library soname: [%s]"), name);
7890 break;
7891
7892 case DT_RPATH:
7893 printf (_("Library rpath: [%s]"), name);
7894 break;
7895
7896 case DT_RUNPATH:
7897 printf (_("Library runpath: [%s]"), name);
7898 break;
7899
7900 default:
7901 print_vma (entry->d_un.d_val, PREFIX_HEX);
7902 break;
7903 }
7904 }
7905 else
7906 print_vma (entry->d_un.d_val, PREFIX_HEX);
7907
7908 putchar ('\n');
7909 }
7910 break;
7911
7912 case DT_PLTRELSZ:
7913 case DT_RELASZ :
7914 case DT_STRSZ :
7915 case DT_RELSZ :
7916 case DT_RELAENT :
7917 case DT_SYMENT :
7918 case DT_RELENT :
7919 dynamic_info[entry->d_tag] = entry->d_un.d_val;
7920 case DT_PLTPADSZ:
7921 case DT_MOVEENT :
7922 case DT_MOVESZ :
7923 case DT_INIT_ARRAYSZ:
7924 case DT_FINI_ARRAYSZ:
7925 case DT_GNU_CONFLICTSZ:
7926 case DT_GNU_LIBLISTSZ:
7927 if (do_dynamic)
7928 {
7929 print_vma (entry->d_un.d_val, UNSIGNED);
7930 printf (_(" (bytes)\n"));
7931 }
7932 break;
7933
7934 case DT_VERDEFNUM:
7935 case DT_VERNEEDNUM:
7936 case DT_RELACOUNT:
7937 case DT_RELCOUNT:
7938 if (do_dynamic)
7939 {
7940 print_vma (entry->d_un.d_val, UNSIGNED);
7941 putchar ('\n');
7942 }
7943 break;
7944
7945 case DT_SYMINSZ:
7946 case DT_SYMINENT:
7947 case DT_SYMINFO:
7948 case DT_USED:
7949 case DT_INIT_ARRAY:
7950 case DT_FINI_ARRAY:
7951 if (do_dynamic)
7952 {
7953 if (entry->d_tag == DT_USED
7954 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
7955 {
7956 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
7957
7958 if (*name)
7959 {
7960 printf (_("Not needed object: [%s]\n"), name);
7961 break;
7962 }
7963 }
7964
7965 print_vma (entry->d_un.d_val, PREFIX_HEX);
7966 putchar ('\n');
7967 }
7968 break;
7969
7970 case DT_BIND_NOW:
7971 /* The value of this entry is ignored. */
7972 if (do_dynamic)
7973 putchar ('\n');
7974 break;
7975
7976 case DT_GNU_PRELINKED:
7977 if (do_dynamic)
7978 {
7979 struct tm * tmp;
7980 time_t atime = entry->d_un.d_val;
7981
7982 tmp = gmtime (&atime);
7983 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
7984 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7985 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7986
7987 }
7988 break;
7989
7990 case DT_GNU_HASH:
7991 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
7992 if (do_dynamic)
7993 {
7994 print_vma (entry->d_un.d_val, PREFIX_HEX);
7995 putchar ('\n');
7996 }
7997 break;
7998
7999 default:
8000 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
8001 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
8002 entry->d_un.d_val;
8003
8004 if (do_dynamic)
8005 {
8006 switch (elf_header.e_machine)
8007 {
8008 case EM_MIPS:
8009 case EM_MIPS_RS3_LE:
8010 dynamic_section_mips_val (entry);
8011 break;
8012 case EM_PARISC:
8013 dynamic_section_parisc_val (entry);
8014 break;
8015 case EM_IA_64:
8016 dynamic_section_ia64_val (entry);
8017 break;
8018 default:
8019 print_vma (entry->d_un.d_val, PREFIX_HEX);
8020 putchar ('\n');
8021 }
8022 }
8023 break;
8024 }
8025 }
8026
8027 return 1;
8028 }
8029
8030 static char *
8031 get_ver_flags (unsigned int flags)
8032 {
8033 static char buff[32];
8034
8035 buff[0] = 0;
8036
8037 if (flags == 0)
8038 return _("none");
8039
8040 if (flags & VER_FLG_BASE)
8041 strcat (buff, "BASE ");
8042
8043 if (flags & VER_FLG_WEAK)
8044 {
8045 if (flags & VER_FLG_BASE)
8046 strcat (buff, "| ");
8047
8048 strcat (buff, "WEAK ");
8049 }
8050
8051 if (flags & VER_FLG_INFO)
8052 {
8053 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
8054 strcat (buff, "| ");
8055
8056 strcat (buff, "INFO ");
8057 }
8058
8059 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
8060 strcat (buff, _("| <unknown>"));
8061
8062 return buff;
8063 }
8064
8065 /* Display the contents of the version sections. */
8066
8067 static int
8068 process_version_sections (FILE * file)
8069 {
8070 Elf_Internal_Shdr * section;
8071 unsigned i;
8072 int found = 0;
8073
8074 if (! do_version)
8075 return 1;
8076
8077 for (i = 0, section = section_headers;
8078 i < elf_header.e_shnum;
8079 i++, section++)
8080 {
8081 switch (section->sh_type)
8082 {
8083 case SHT_GNU_verdef:
8084 {
8085 Elf_External_Verdef * edefs;
8086 unsigned int idx;
8087 unsigned int cnt;
8088 char * endbuf;
8089
8090 found = 1;
8091
8092 printf
8093 (_("\nVersion definition section '%s' contains %u entries:\n"),
8094 SECTION_NAME (section), section->sh_info);
8095
8096 printf (_(" Addr: 0x"));
8097 printf_vma (section->sh_addr);
8098 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8099 (unsigned long) section->sh_offset, section->sh_link,
8100 section->sh_link < elf_header.e_shnum
8101 ? SECTION_NAME (section_headers + section->sh_link)
8102 : _("<corrupt>"));
8103
8104 edefs = (Elf_External_Verdef *)
8105 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
8106 _("version definition section"));
8107 if (!edefs)
8108 break;
8109 endbuf = (char *) edefs + section->sh_size;
8110
8111 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8112 {
8113 char * vstart;
8114 Elf_External_Verdef * edef;
8115 Elf_Internal_Verdef ent;
8116 Elf_External_Verdaux * eaux;
8117 Elf_Internal_Verdaux aux;
8118 int j;
8119 int isum;
8120
8121 /* Check for negative or very large indicies. */
8122 if ((unsigned char *) edefs + idx < (unsigned char *) edefs)
8123 break;
8124
8125 vstart = ((char *) edefs) + idx;
8126 if (vstart + sizeof (*edef) > endbuf)
8127 break;
8128
8129 edef = (Elf_External_Verdef *) vstart;
8130
8131 ent.vd_version = BYTE_GET (edef->vd_version);
8132 ent.vd_flags = BYTE_GET (edef->vd_flags);
8133 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
8134 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
8135 ent.vd_hash = BYTE_GET (edef->vd_hash);
8136 ent.vd_aux = BYTE_GET (edef->vd_aux);
8137 ent.vd_next = BYTE_GET (edef->vd_next);
8138
8139 printf (_(" %#06x: Rev: %d Flags: %s"),
8140 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
8141
8142 printf (_(" Index: %d Cnt: %d "),
8143 ent.vd_ndx, ent.vd_cnt);
8144
8145 /* Check for overflow. */
8146 if ((unsigned char *)(vstart + ent.vd_aux) < (unsigned char *) vstart
8147 || (unsigned char *)(vstart + ent.vd_aux) > (unsigned char *) endbuf)
8148 break;
8149
8150 vstart += ent.vd_aux;
8151
8152 eaux = (Elf_External_Verdaux *) vstart;
8153
8154 aux.vda_name = BYTE_GET (eaux->vda_name);
8155 aux.vda_next = BYTE_GET (eaux->vda_next);
8156
8157 if (VALID_DYNAMIC_NAME (aux.vda_name))
8158 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
8159 else
8160 printf (_("Name index: %ld\n"), aux.vda_name);
8161
8162 isum = idx + ent.vd_aux;
8163
8164 for (j = 1; j < ent.vd_cnt; j++)
8165 {
8166 /* Check for overflow. */
8167 if ((unsigned char *)(vstart + aux.vda_next) < (unsigned char *) vstart
8168 || (unsigned char *)(vstart + aux.vda_next) > (unsigned char *) endbuf)
8169 break;
8170
8171 isum += aux.vda_next;
8172 vstart += aux.vda_next;
8173
8174 eaux = (Elf_External_Verdaux *) vstart;
8175 if (vstart + sizeof (*eaux) > endbuf)
8176 break;
8177
8178 aux.vda_name = BYTE_GET (eaux->vda_name);
8179 aux.vda_next = BYTE_GET (eaux->vda_next);
8180
8181 if (VALID_DYNAMIC_NAME (aux.vda_name))
8182 printf (_(" %#06x: Parent %d: %s\n"),
8183 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
8184 else
8185 printf (_(" %#06x: Parent %d, name index: %ld\n"),
8186 isum, j, aux.vda_name);
8187 }
8188
8189 if (j < ent.vd_cnt)
8190 printf (_(" Version def aux past end of section\n"));
8191
8192 idx += ent.vd_next;
8193 }
8194
8195 if (cnt < section->sh_info)
8196 printf (_(" Version definition past end of section\n"));
8197
8198 free (edefs);
8199 }
8200 break;
8201
8202 case SHT_GNU_verneed:
8203 {
8204 Elf_External_Verneed * eneed;
8205 unsigned int idx;
8206 unsigned int cnt;
8207 char * endbuf;
8208
8209 found = 1;
8210
8211 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
8212 SECTION_NAME (section), section->sh_info);
8213
8214 printf (_(" Addr: 0x"));
8215 printf_vma (section->sh_addr);
8216 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8217 (unsigned long) section->sh_offset, section->sh_link,
8218 section->sh_link < elf_header.e_shnum
8219 ? SECTION_NAME (section_headers + section->sh_link)
8220 : _("<corrupt>"));
8221
8222 eneed = (Elf_External_Verneed *) get_data (NULL, file,
8223 section->sh_offset, 1,
8224 section->sh_size,
8225 _("version need section"));
8226 if (!eneed)
8227 break;
8228 endbuf = (char *) eneed + section->sh_size;
8229
8230 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8231 {
8232 Elf_External_Verneed * entry;
8233 Elf_Internal_Verneed ent;
8234 int j;
8235 int isum;
8236 char * vstart;
8237
8238 if ((unsigned char *) eneed + idx < (unsigned char *) eneed)
8239 break;
8240
8241 vstart = ((char *) eneed) + idx;
8242 if (vstart + sizeof (*entry) > endbuf)
8243 break;
8244
8245 entry = (Elf_External_Verneed *) vstart;
8246
8247 ent.vn_version = BYTE_GET (entry->vn_version);
8248 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
8249 ent.vn_file = BYTE_GET (entry->vn_file);
8250 ent.vn_aux = BYTE_GET (entry->vn_aux);
8251 ent.vn_next = BYTE_GET (entry->vn_next);
8252
8253 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
8254
8255 if (VALID_DYNAMIC_NAME (ent.vn_file))
8256 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
8257 else
8258 printf (_(" File: %lx"), ent.vn_file);
8259
8260 printf (_(" Cnt: %d\n"), ent.vn_cnt);
8261
8262 /* Check for overflow. */
8263 if ((unsigned char *)(vstart + ent.vn_aux) < (unsigned char *) vstart
8264 || (unsigned char *)(vstart + ent.vn_aux) > (unsigned char *) endbuf)
8265 break;
8266
8267 vstart += ent.vn_aux;
8268
8269 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
8270 {
8271 Elf_External_Vernaux * eaux;
8272 Elf_Internal_Vernaux aux;
8273
8274 if (vstart + sizeof (*eaux) > endbuf)
8275 break;
8276 eaux = (Elf_External_Vernaux *) vstart;
8277
8278 aux.vna_hash = BYTE_GET (eaux->vna_hash);
8279 aux.vna_flags = BYTE_GET (eaux->vna_flags);
8280 aux.vna_other = BYTE_GET (eaux->vna_other);
8281 aux.vna_name = BYTE_GET (eaux->vna_name);
8282 aux.vna_next = BYTE_GET (eaux->vna_next);
8283
8284 if (VALID_DYNAMIC_NAME (aux.vna_name))
8285 printf (_(" %#06x: Name: %s"),
8286 isum, GET_DYNAMIC_NAME (aux.vna_name));
8287 else
8288 printf (_(" %#06x: Name index: %lx"),
8289 isum, aux.vna_name);
8290
8291 printf (_(" Flags: %s Version: %d\n"),
8292 get_ver_flags (aux.vna_flags), aux.vna_other);
8293
8294 /* Check for overflow. */
8295 if ((unsigned char *)(vstart + aux.vna_next) < (unsigned char *) vstart
8296 || (unsigned char *)(vstart + aux.vna_next) > (unsigned char *) endbuf)
8297 break;
8298
8299 isum += aux.vna_next;
8300 vstart += aux.vna_next;
8301 }
8302 if (j < ent.vn_cnt)
8303 printf (_(" Version need aux past end of section\n"));
8304
8305 idx += ent.vn_next;
8306 }
8307 if (cnt < section->sh_info)
8308 printf (_(" Version need past end of section\n"));
8309
8310 free (eneed);
8311 }
8312 break;
8313
8314 case SHT_GNU_versym:
8315 {
8316 Elf_Internal_Shdr * link_section;
8317 int total;
8318 int cnt;
8319 unsigned char * edata;
8320 unsigned short * data;
8321 char * strtab;
8322 Elf_Internal_Sym * symbols;
8323 Elf_Internal_Shdr * string_sec;
8324 long off;
8325
8326 if (section->sh_link >= elf_header.e_shnum)
8327 break;
8328
8329 link_section = section_headers + section->sh_link;
8330 total = section->sh_size / sizeof (Elf_External_Versym);
8331
8332 if (link_section->sh_link >= elf_header.e_shnum)
8333 break;
8334
8335 found = 1;
8336
8337 symbols = GET_ELF_SYMBOLS (file, link_section);
8338 if (symbols == NULL)
8339 break;
8340
8341 string_sec = section_headers + link_section->sh_link;
8342
8343 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
8344 string_sec->sh_size,
8345 _("version string table"));
8346 if (!strtab)
8347 {
8348 free (symbols);
8349 break;
8350 }
8351
8352 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8353 SECTION_NAME (section), total);
8354
8355 printf (_(" Addr: "));
8356 printf_vma (section->sh_addr);
8357 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8358 (unsigned long) section->sh_offset, section->sh_link,
8359 SECTION_NAME (link_section));
8360
8361 off = offset_from_vma (file,
8362 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
8363 total * sizeof (short));
8364 edata = (unsigned char *) get_data (NULL, file, off, total,
8365 sizeof (short),
8366 _("version symbol data"));
8367 if (!edata)
8368 {
8369 free (strtab);
8370 free (symbols);
8371 break;
8372 }
8373
8374 data = (short unsigned int *) cmalloc (total, sizeof (short));
8375
8376 for (cnt = total; cnt --;)
8377 data[cnt] = byte_get (edata + cnt * sizeof (short),
8378 sizeof (short));
8379
8380 free (edata);
8381
8382 for (cnt = 0; cnt < total; cnt += 4)
8383 {
8384 int j, nn;
8385 int check_def, check_need;
8386 char * name;
8387
8388 printf (" %03x:", cnt);
8389
8390 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
8391 switch (data[cnt + j])
8392 {
8393 case 0:
8394 fputs (_(" 0 (*local*) "), stdout);
8395 break;
8396
8397 case 1:
8398 fputs (_(" 1 (*global*) "), stdout);
8399 break;
8400
8401 default:
8402 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
8403 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
8404
8405 /* If this index value is greater than the size of the symbols
8406 array, break to avoid an out-of-bounds read, */
8407 if ((unsigned long)(cnt + j) >=
8408 ((unsigned long)link_section->sh_size /
8409 (unsigned long)link_section->sh_entsize))
8410 {
8411 warn (_("invalid index into symbol array\n"));
8412 break;
8413 }
8414
8415 check_def = 1;
8416 check_need = 1;
8417 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
8418 || section_headers[symbols[cnt + j].st_shndx].sh_type
8419 != SHT_NOBITS)
8420 {
8421 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
8422 check_def = 0;
8423 else
8424 check_need = 0;
8425 }
8426
8427 if (check_need
8428 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
8429 {
8430 Elf_Internal_Verneed ivn;
8431 unsigned long offset;
8432
8433 offset = offset_from_vma
8434 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8435 sizeof (Elf_External_Verneed));
8436
8437 do
8438 {
8439 Elf_Internal_Vernaux ivna;
8440 Elf_External_Verneed evn;
8441 Elf_External_Vernaux evna;
8442 unsigned long a_off;
8443
8444 if (get_data (&evn, file, offset, sizeof (evn), 1,
8445 _("version need")) == NULL)
8446 break;
8447
8448 ivn.vn_aux = BYTE_GET (evn.vn_aux);
8449 ivn.vn_next = BYTE_GET (evn.vn_next);
8450
8451 a_off = offset + ivn.vn_aux;
8452
8453 do
8454 {
8455 if (get_data (&evna, file, a_off, sizeof (evna),
8456 1, _("version need aux (2)")) == NULL)
8457 {
8458 ivna.vna_next = 0;
8459 ivna.vna_other = 0;
8460 }
8461 else
8462 {
8463 ivna.vna_next = BYTE_GET (evna.vna_next);
8464 ivna.vna_other = BYTE_GET (evna.vna_other);
8465 }
8466
8467 a_off += ivna.vna_next;
8468 }
8469 while (ivna.vna_other != data[cnt + j]
8470 && ivna.vna_next != 0);
8471
8472 if (ivna.vna_other == data[cnt + j])
8473 {
8474 ivna.vna_name = BYTE_GET (evna.vna_name);
8475
8476 if (ivna.vna_name >= string_sec->sh_size)
8477 name = _("*invalid*");
8478 else
8479 name = strtab + ivna.vna_name;
8480 nn += printf ("(%s%-*s",
8481 name,
8482 12 - (int) strlen (name),
8483 ")");
8484 check_def = 0;
8485 break;
8486 }
8487
8488 offset += ivn.vn_next;
8489 }
8490 while (ivn.vn_next);
8491 }
8492
8493 if (check_def && data[cnt + j] != 0x8001
8494 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
8495 {
8496 Elf_Internal_Verdef ivd;
8497 Elf_External_Verdef evd;
8498 unsigned long offset;
8499
8500 offset = offset_from_vma
8501 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8502 sizeof evd);
8503
8504 do
8505 {
8506 if (get_data (&evd, file, offset, sizeof (evd), 1,
8507 _("version def")) == NULL)
8508 {
8509 ivd.vd_next = 0;
8510 ivd.vd_ndx = 0;
8511 }
8512 else
8513 {
8514 ivd.vd_next = BYTE_GET (evd.vd_next);
8515 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
8516 }
8517
8518 offset += ivd.vd_next;
8519 }
8520 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
8521 && ivd.vd_next != 0);
8522
8523 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
8524 {
8525 Elf_External_Verdaux evda;
8526 Elf_Internal_Verdaux ivda;
8527
8528 ivd.vd_aux = BYTE_GET (evd.vd_aux);
8529
8530 if (get_data (&evda, file,
8531 offset - ivd.vd_next + ivd.vd_aux,
8532 sizeof (evda), 1,
8533 _("version def aux")) == NULL)
8534 break;
8535
8536 ivda.vda_name = BYTE_GET (evda.vda_name);
8537
8538 if (ivda.vda_name >= string_sec->sh_size)
8539 name = _("*invalid*");
8540 else
8541 name = strtab + ivda.vda_name;
8542 nn += printf ("(%s%-*s",
8543 name,
8544 12 - (int) strlen (name),
8545 ")");
8546 }
8547 }
8548
8549 if (nn < 18)
8550 printf ("%*c", 18 - nn, ' ');
8551 }
8552
8553 putchar ('\n');
8554 }
8555
8556 free (data);
8557 free (strtab);
8558 free (symbols);
8559 }
8560 break;
8561
8562 default:
8563 break;
8564 }
8565 }
8566
8567 if (! found)
8568 printf (_("\nNo version information found in this file.\n"));
8569
8570 return 1;
8571 }
8572
8573 static const char *
8574 get_symbol_binding (unsigned int binding)
8575 {
8576 static char buff[32];
8577
8578 switch (binding)
8579 {
8580 case STB_LOCAL: return "LOCAL";
8581 case STB_GLOBAL: return "GLOBAL";
8582 case STB_WEAK: return "WEAK";
8583 default:
8584 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
8585 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
8586 binding);
8587 else if (binding >= STB_LOOS && binding <= STB_HIOS)
8588 {
8589 if (binding == STB_GNU_UNIQUE
8590 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_LINUX
8591 /* GNU/Linux is still using the default value 0. */
8592 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8593 return "UNIQUE";
8594 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
8595 }
8596 else
8597 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
8598 return buff;
8599 }
8600 }
8601
8602 static const char *
8603 get_symbol_type (unsigned int type)
8604 {
8605 static char buff[32];
8606
8607 switch (type)
8608 {
8609 case STT_NOTYPE: return "NOTYPE";
8610 case STT_OBJECT: return "OBJECT";
8611 case STT_FUNC: return "FUNC";
8612 case STT_SECTION: return "SECTION";
8613 case STT_FILE: return "FILE";
8614 case STT_COMMON: return "COMMON";
8615 case STT_TLS: return "TLS";
8616 case STT_RELC: return "RELC";
8617 case STT_SRELC: return "SRELC";
8618 default:
8619 if (type >= STT_LOPROC && type <= STT_HIPROC)
8620 {
8621 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
8622 return "THUMB_FUNC";
8623
8624 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
8625 return "REGISTER";
8626
8627 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
8628 return "PARISC_MILLI";
8629
8630 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
8631 }
8632 else if (type >= STT_LOOS && type <= STT_HIOS)
8633 {
8634 if (elf_header.e_machine == EM_PARISC)
8635 {
8636 if (type == STT_HP_OPAQUE)
8637 return "HP_OPAQUE";
8638 if (type == STT_HP_STUB)
8639 return "HP_STUB";
8640 }
8641
8642 if (type == STT_GNU_IFUNC
8643 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_LINUX
8644 /* GNU/Linux is still using the default value 0. */
8645 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8646 return "IFUNC";
8647
8648 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
8649 }
8650 else
8651 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
8652 return buff;
8653 }
8654 }
8655
8656 static const char *
8657 get_symbol_visibility (unsigned int visibility)
8658 {
8659 switch (visibility)
8660 {
8661 case STV_DEFAULT: return "DEFAULT";
8662 case STV_INTERNAL: return "INTERNAL";
8663 case STV_HIDDEN: return "HIDDEN";
8664 case STV_PROTECTED: return "PROTECTED";
8665 default: abort ();
8666 }
8667 }
8668
8669 static const char *
8670 get_mips_symbol_other (unsigned int other)
8671 {
8672 switch (other)
8673 {
8674 case STO_OPTIONAL: return "OPTIONAL";
8675 case STO_MIPS16: return "MIPS16";
8676 case STO_MIPS_PLT: return "MIPS PLT";
8677 case STO_MIPS_PIC: return "MIPS PIC";
8678 default: return NULL;
8679 }
8680 }
8681
8682 static const char *
8683 get_ia64_symbol_other (unsigned int other)
8684 {
8685 if (is_ia64_vms ())
8686 {
8687 static char res[32];
8688
8689 res[0] = 0;
8690
8691 /* Function types is for images and .STB files only. */
8692 switch (elf_header.e_type)
8693 {
8694 case ET_DYN:
8695 case ET_EXEC:
8696 switch (VMS_ST_FUNC_TYPE (other))
8697 {
8698 case VMS_SFT_CODE_ADDR:
8699 strcat (res, " CA");
8700 break;
8701 case VMS_SFT_SYMV_IDX:
8702 strcat (res, " VEC");
8703 break;
8704 case VMS_SFT_FD:
8705 strcat (res, " FD");
8706 break;
8707 case VMS_SFT_RESERVE:
8708 strcat (res, " RSV");
8709 break;
8710 default:
8711 abort ();
8712 }
8713 break;
8714 default:
8715 break;
8716 }
8717 switch (VMS_ST_LINKAGE (other))
8718 {
8719 case VMS_STL_IGNORE:
8720 strcat (res, " IGN");
8721 break;
8722 case VMS_STL_RESERVE:
8723 strcat (res, " RSV");
8724 break;
8725 case VMS_STL_STD:
8726 strcat (res, " STD");
8727 break;
8728 case VMS_STL_LNK:
8729 strcat (res, " LNK");
8730 break;
8731 default:
8732 abort ();
8733 }
8734
8735 if (res[0] != 0)
8736 return res + 1;
8737 else
8738 return res;
8739 }
8740 return NULL;
8741 }
8742
8743 static const char *
8744 get_symbol_other (unsigned int other)
8745 {
8746 const char * result = NULL;
8747 static char buff [32];
8748
8749 if (other == 0)
8750 return "";
8751
8752 switch (elf_header.e_machine)
8753 {
8754 case EM_MIPS:
8755 result = get_mips_symbol_other (other);
8756 break;
8757 case EM_IA_64:
8758 result = get_ia64_symbol_other (other);
8759 break;
8760 default:
8761 break;
8762 }
8763
8764 if (result)
8765 return result;
8766
8767 snprintf (buff, sizeof buff, _("<other>: %x"), other);
8768 return buff;
8769 }
8770
8771 static const char *
8772 get_symbol_index_type (unsigned int type)
8773 {
8774 static char buff[32];
8775
8776 switch (type)
8777 {
8778 case SHN_UNDEF: return "UND";
8779 case SHN_ABS: return "ABS";
8780 case SHN_COMMON: return "COM";
8781 default:
8782 if (type == SHN_IA_64_ANSI_COMMON
8783 && elf_header.e_machine == EM_IA_64
8784 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
8785 return "ANSI_COM";
8786 else if ((elf_header.e_machine == EM_X86_64
8787 || elf_header.e_machine == EM_L1OM)
8788 && type == SHN_X86_64_LCOMMON)
8789 return "LARGE_COM";
8790 else if ((type == SHN_MIPS_SCOMMON
8791 && elf_header.e_machine == EM_MIPS)
8792 || (type == SHN_TIC6X_SCOMMON
8793 && elf_header.e_machine == EM_TI_C6000))
8794 return "SCOM";
8795 else if (type == SHN_MIPS_SUNDEFINED
8796 && elf_header.e_machine == EM_MIPS)
8797 return "SUND";
8798 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
8799 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
8800 else if (type >= SHN_LOOS && type <= SHN_HIOS)
8801 sprintf (buff, "OS [0x%04x]", type & 0xffff);
8802 else if (type >= SHN_LORESERVE)
8803 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
8804 else
8805 sprintf (buff, "%3d", type);
8806 break;
8807 }
8808
8809 return buff;
8810 }
8811
8812 static bfd_vma *
8813 get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
8814 {
8815 unsigned char * e_data;
8816 bfd_vma * i_data;
8817
8818 e_data = (unsigned char *) cmalloc (number, ent_size);
8819
8820 if (e_data == NULL)
8821 {
8822 error (_("Out of memory\n"));
8823 return NULL;
8824 }
8825
8826 if (fread (e_data, ent_size, number, file) != number)
8827 {
8828 error (_("Unable to read in dynamic data\n"));
8829 return NULL;
8830 }
8831
8832 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
8833
8834 if (i_data == NULL)
8835 {
8836 error (_("Out of memory\n"));
8837 free (e_data);
8838 return NULL;
8839 }
8840
8841 while (number--)
8842 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
8843
8844 free (e_data);
8845
8846 return i_data;
8847 }
8848
8849 static void
8850 print_dynamic_symbol (bfd_vma si, unsigned long hn)
8851 {
8852 Elf_Internal_Sym * psym;
8853 int n;
8854
8855 psym = dynamic_symbols + si;
8856
8857 n = print_vma (si, DEC_5);
8858 if (n < 5)
8859 fputs (" " + n, stdout);
8860 printf (" %3lu: ", hn);
8861 print_vma (psym->st_value, LONG_HEX);
8862 putchar (' ');
8863 print_vma (psym->st_size, DEC_5);
8864
8865 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
8866 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
8867 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
8868 /* Check to see if any other bits in the st_other field are set.
8869 Note - displaying this information disrupts the layout of the
8870 table being generated, but for the moment this case is very
8871 rare. */
8872 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
8873 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
8874 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
8875 if (VALID_DYNAMIC_NAME (psym->st_name))
8876 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
8877 else
8878 printf (_(" <corrupt: %14ld>"), psym->st_name);
8879 putchar ('\n');
8880 }
8881
8882 /* Dump the symbol table. */
8883 static int
8884 process_symbol_table (FILE * file)
8885 {
8886 Elf_Internal_Shdr * section;
8887 bfd_vma nbuckets = 0;
8888 bfd_vma nchains = 0;
8889 bfd_vma * buckets = NULL;
8890 bfd_vma * chains = NULL;
8891 bfd_vma ngnubuckets = 0;
8892 bfd_vma * gnubuckets = NULL;
8893 bfd_vma * gnuchains = NULL;
8894 bfd_vma gnusymidx = 0;
8895
8896 if (!do_syms && !do_dyn_syms && !do_histogram)
8897 return 1;
8898
8899 if (dynamic_info[DT_HASH]
8900 && (do_histogram
8901 || (do_using_dynamic
8902 && !do_dyn_syms
8903 && dynamic_strings != NULL)))
8904 {
8905 unsigned char nb[8];
8906 unsigned char nc[8];
8907 int hash_ent_size = 4;
8908
8909 if ((elf_header.e_machine == EM_ALPHA
8910 || elf_header.e_machine == EM_S390
8911 || elf_header.e_machine == EM_S390_OLD)
8912 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
8913 hash_ent_size = 8;
8914
8915 if (fseek (file,
8916 (archive_file_offset
8917 + offset_from_vma (file, dynamic_info[DT_HASH],
8918 sizeof nb + sizeof nc)),
8919 SEEK_SET))
8920 {
8921 error (_("Unable to seek to start of dynamic information\n"));
8922 goto no_hash;
8923 }
8924
8925 if (fread (nb, hash_ent_size, 1, file) != 1)
8926 {
8927 error (_("Failed to read in number of buckets\n"));
8928 goto no_hash;
8929 }
8930
8931 if (fread (nc, hash_ent_size, 1, file) != 1)
8932 {
8933 error (_("Failed to read in number of chains\n"));
8934 goto no_hash;
8935 }
8936
8937 nbuckets = byte_get (nb, hash_ent_size);
8938 nchains = byte_get (nc, hash_ent_size);
8939
8940 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
8941 chains = get_dynamic_data (file, nchains, hash_ent_size);
8942
8943 no_hash:
8944 if (buckets == NULL || chains == NULL)
8945 {
8946 if (do_using_dynamic)
8947 return 0;
8948 free (buckets);
8949 free (chains);
8950 buckets = NULL;
8951 chains = NULL;
8952 nbuckets = 0;
8953 nchains = 0;
8954 }
8955 }
8956
8957 if (dynamic_info_DT_GNU_HASH
8958 && (do_histogram
8959 || (do_using_dynamic
8960 && !do_dyn_syms
8961 && dynamic_strings != NULL)))
8962 {
8963 unsigned char nb[16];
8964 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
8965 bfd_vma buckets_vma;
8966
8967 if (fseek (file,
8968 (archive_file_offset
8969 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
8970 sizeof nb)),
8971 SEEK_SET))
8972 {
8973 error (_("Unable to seek to start of dynamic information\n"));
8974 goto no_gnu_hash;
8975 }
8976
8977 if (fread (nb, 16, 1, file) != 1)
8978 {
8979 error (_("Failed to read in number of buckets\n"));
8980 goto no_gnu_hash;
8981 }
8982
8983 ngnubuckets = byte_get (nb, 4);
8984 gnusymidx = byte_get (nb + 4, 4);
8985 bitmaskwords = byte_get (nb + 8, 4);
8986 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
8987 if (is_32bit_elf)
8988 buckets_vma += bitmaskwords * 4;
8989 else
8990 buckets_vma += bitmaskwords * 8;
8991
8992 if (fseek (file,
8993 (archive_file_offset
8994 + offset_from_vma (file, buckets_vma, 4)),
8995 SEEK_SET))
8996 {
8997 error (_("Unable to seek to start of dynamic information\n"));
8998 goto no_gnu_hash;
8999 }
9000
9001 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
9002
9003 if (gnubuckets == NULL)
9004 goto no_gnu_hash;
9005
9006 for (i = 0; i < ngnubuckets; i++)
9007 if (gnubuckets[i] != 0)
9008 {
9009 if (gnubuckets[i] < gnusymidx)
9010 return 0;
9011
9012 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
9013 maxchain = gnubuckets[i];
9014 }
9015
9016 if (maxchain == 0xffffffff)
9017 goto no_gnu_hash;
9018
9019 maxchain -= gnusymidx;
9020
9021 if (fseek (file,
9022 (archive_file_offset
9023 + offset_from_vma (file, buckets_vma
9024 + 4 * (ngnubuckets + maxchain), 4)),
9025 SEEK_SET))
9026 {
9027 error (_("Unable to seek to start of dynamic information\n"));
9028 goto no_gnu_hash;
9029 }
9030
9031 do
9032 {
9033 if (fread (nb, 4, 1, file) != 1)
9034 {
9035 error (_("Failed to determine last chain length\n"));
9036 goto no_gnu_hash;
9037 }
9038
9039 if (maxchain + 1 == 0)
9040 goto no_gnu_hash;
9041
9042 ++maxchain;
9043 }
9044 while ((byte_get (nb, 4) & 1) == 0);
9045
9046 if (fseek (file,
9047 (archive_file_offset
9048 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
9049 SEEK_SET))
9050 {
9051 error (_("Unable to seek to start of dynamic information\n"));
9052 goto no_gnu_hash;
9053 }
9054
9055 gnuchains = get_dynamic_data (file, maxchain, 4);
9056
9057 no_gnu_hash:
9058 if (gnuchains == NULL)
9059 {
9060 free (gnubuckets);
9061 gnubuckets = NULL;
9062 ngnubuckets = 0;
9063 if (do_using_dynamic)
9064 return 0;
9065 }
9066 }
9067
9068 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
9069 && do_syms
9070 && do_using_dynamic
9071 && dynamic_strings != NULL)
9072 {
9073 unsigned long hn;
9074
9075 if (dynamic_info[DT_HASH])
9076 {
9077 bfd_vma si;
9078
9079 printf (_("\nSymbol table for image:\n"));
9080 if (is_32bit_elf)
9081 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9082 else
9083 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9084
9085 for (hn = 0; hn < nbuckets; hn++)
9086 {
9087 if (! buckets[hn])
9088 continue;
9089
9090 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
9091 print_dynamic_symbol (si, hn);
9092 }
9093 }
9094
9095 if (dynamic_info_DT_GNU_HASH)
9096 {
9097 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9098 if (is_32bit_elf)
9099 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9100 else
9101 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9102
9103 for (hn = 0; hn < ngnubuckets; ++hn)
9104 if (gnubuckets[hn] != 0)
9105 {
9106 bfd_vma si = gnubuckets[hn];
9107 bfd_vma off = si - gnusymidx;
9108
9109 do
9110 {
9111 print_dynamic_symbol (si, hn);
9112 si++;
9113 }
9114 while ((gnuchains[off++] & 1) == 0);
9115 }
9116 }
9117 }
9118 else if (do_dyn_syms || (do_syms && !do_using_dynamic))
9119 {
9120 unsigned int i;
9121
9122 for (i = 0, section = section_headers;
9123 i < elf_header.e_shnum;
9124 i++, section++)
9125 {
9126 unsigned int si;
9127 char * strtab = NULL;
9128 unsigned long int strtab_size = 0;
9129 Elf_Internal_Sym * symtab;
9130 Elf_Internal_Sym * psym;
9131
9132 if ((section->sh_type != SHT_SYMTAB
9133 && section->sh_type != SHT_DYNSYM)
9134 || (!do_syms
9135 && section->sh_type == SHT_SYMTAB))
9136 continue;
9137
9138 if (section->sh_entsize == 0)
9139 {
9140 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9141 SECTION_NAME (section));
9142 continue;
9143 }
9144
9145 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9146 SECTION_NAME (section),
9147 (unsigned long) (section->sh_size / section->sh_entsize));
9148
9149 if (is_32bit_elf)
9150 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9151 else
9152 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9153
9154 symtab = GET_ELF_SYMBOLS (file, section);
9155 if (symtab == NULL)
9156 continue;
9157
9158 if (section->sh_link == elf_header.e_shstrndx)
9159 {
9160 strtab = string_table;
9161 strtab_size = string_table_length;
9162 }
9163 else if (section->sh_link < elf_header.e_shnum)
9164 {
9165 Elf_Internal_Shdr * string_sec;
9166
9167 string_sec = section_headers + section->sh_link;
9168
9169 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
9170 1, string_sec->sh_size,
9171 _("string table"));
9172 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
9173 }
9174
9175 for (si = 0, psym = symtab;
9176 si < section->sh_size / section->sh_entsize;
9177 si++, psym++)
9178 {
9179 printf ("%6d: ", si);
9180 print_vma (psym->st_value, LONG_HEX);
9181 putchar (' ');
9182 print_vma (psym->st_size, DEC_5);
9183 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9184 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9185 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
9186 /* Check to see if any other bits in the st_other field are set.
9187 Note - displaying this information disrupts the layout of the
9188 table being generated, but for the moment this case is very rare. */
9189 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9190 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9191 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
9192 print_symbol (25, psym->st_name < strtab_size
9193 ? strtab + psym->st_name : _("<corrupt>"));
9194
9195 if (section->sh_type == SHT_DYNSYM
9196 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
9197 {
9198 unsigned char data[2];
9199 unsigned short vers_data;
9200 unsigned long offset;
9201 int is_nobits;
9202 int check_def;
9203
9204 offset = offset_from_vma
9205 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9206 sizeof data + si * sizeof (vers_data));
9207
9208 if (get_data (&data, file, offset + si * sizeof (vers_data),
9209 sizeof (data), 1, _("version data")) == NULL)
9210 break;
9211
9212 vers_data = byte_get (data, 2);
9213
9214 is_nobits = (psym->st_shndx < elf_header.e_shnum
9215 && section_headers[psym->st_shndx].sh_type
9216 == SHT_NOBITS);
9217
9218 check_def = (psym->st_shndx != SHN_UNDEF);
9219
9220 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
9221 {
9222 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
9223 && (is_nobits || ! check_def))
9224 {
9225 Elf_External_Verneed evn;
9226 Elf_Internal_Verneed ivn;
9227 Elf_Internal_Vernaux ivna;
9228
9229 /* We must test both. */
9230 offset = offset_from_vma
9231 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9232 sizeof evn);
9233
9234 do
9235 {
9236 unsigned long vna_off;
9237
9238 if (get_data (&evn, file, offset, sizeof (evn), 1,
9239 _("version need")) == NULL)
9240 {
9241 ivna.vna_next = 0;
9242 ivna.vna_other = 0;
9243 ivna.vna_name = 0;
9244 break;
9245 }
9246
9247 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9248 ivn.vn_next = BYTE_GET (evn.vn_next);
9249
9250 vna_off = offset + ivn.vn_aux;
9251
9252 do
9253 {
9254 Elf_External_Vernaux evna;
9255
9256 if (get_data (&evna, file, vna_off,
9257 sizeof (evna), 1,
9258 _("version need aux (3)")) == NULL)
9259 {
9260 ivna.vna_next = 0;
9261 ivna.vna_other = 0;
9262 ivna.vna_name = 0;
9263 }
9264 else
9265 {
9266 ivna.vna_other = BYTE_GET (evna.vna_other);
9267 ivna.vna_next = BYTE_GET (evna.vna_next);
9268 ivna.vna_name = BYTE_GET (evna.vna_name);
9269 }
9270
9271 vna_off += ivna.vna_next;
9272 }
9273 while (ivna.vna_other != vers_data
9274 && ivna.vna_next != 0);
9275
9276 if (ivna.vna_other == vers_data)
9277 break;
9278
9279 offset += ivn.vn_next;
9280 }
9281 while (ivn.vn_next != 0);
9282
9283 if (ivna.vna_other == vers_data)
9284 {
9285 printf ("@%s (%d)",
9286 ivna.vna_name < strtab_size
9287 ? strtab + ivna.vna_name : _("<corrupt>"),
9288 ivna.vna_other);
9289 check_def = 0;
9290 }
9291 else if (! is_nobits)
9292 error (_("bad dynamic symbol\n"));
9293 else
9294 check_def = 1;
9295 }
9296
9297 if (check_def)
9298 {
9299 if (vers_data != 0x8001
9300 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
9301 {
9302 Elf_Internal_Verdef ivd;
9303 Elf_Internal_Verdaux ivda;
9304 Elf_External_Verdaux evda;
9305 unsigned long off;
9306
9307 off = offset_from_vma
9308 (file,
9309 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9310 sizeof (Elf_External_Verdef));
9311
9312 do
9313 {
9314 Elf_External_Verdef evd;
9315
9316 if (get_data (&evd, file, off, sizeof (evd),
9317 1, _("version def")) == NULL)
9318 {
9319 ivd.vd_ndx = 0;
9320 ivd.vd_aux = 0;
9321 ivd.vd_next = 0;
9322 }
9323 else
9324 {
9325 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9326 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9327 ivd.vd_next = BYTE_GET (evd.vd_next);
9328 }
9329
9330 off += ivd.vd_next;
9331 }
9332 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
9333 && ivd.vd_next != 0);
9334
9335 off -= ivd.vd_next;
9336 off += ivd.vd_aux;
9337
9338 if (get_data (&evda, file, off, sizeof (evda),
9339 1, _("version def aux")) == NULL)
9340 break;
9341
9342 ivda.vda_name = BYTE_GET (evda.vda_name);
9343
9344 if (psym->st_name != ivda.vda_name)
9345 printf ((vers_data & VERSYM_HIDDEN)
9346 ? "@%s" : "@@%s",
9347 ivda.vda_name < strtab_size
9348 ? strtab + ivda.vda_name : _("<corrupt>"));
9349 }
9350 }
9351 }
9352 }
9353
9354 putchar ('\n');
9355 }
9356
9357 free (symtab);
9358 if (strtab != string_table)
9359 free (strtab);
9360 }
9361 }
9362 else if (do_syms)
9363 printf
9364 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9365
9366 if (do_histogram && buckets != NULL)
9367 {
9368 unsigned long * lengths;
9369 unsigned long * counts;
9370 unsigned long hn;
9371 bfd_vma si;
9372 unsigned long maxlength = 0;
9373 unsigned long nzero_counts = 0;
9374 unsigned long nsyms = 0;
9375
9376 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9377 (unsigned long) nbuckets);
9378 printf (_(" Length Number %% of total Coverage\n"));
9379
9380 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
9381 if (lengths == NULL)
9382 {
9383 error (_("Out of memory\n"));
9384 return 0;
9385 }
9386 for (hn = 0; hn < nbuckets; ++hn)
9387 {
9388 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
9389 {
9390 ++nsyms;
9391 if (maxlength < ++lengths[hn])
9392 ++maxlength;
9393 }
9394 }
9395
9396 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
9397 if (counts == NULL)
9398 {
9399 error (_("Out of memory\n"));
9400 return 0;
9401 }
9402
9403 for (hn = 0; hn < nbuckets; ++hn)
9404 ++counts[lengths[hn]];
9405
9406 if (nbuckets > 0)
9407 {
9408 unsigned long i;
9409 printf (" 0 %-10lu (%5.1f%%)\n",
9410 counts[0], (counts[0] * 100.0) / nbuckets);
9411 for (i = 1; i <= maxlength; ++i)
9412 {
9413 nzero_counts += counts[i] * i;
9414 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9415 i, counts[i], (counts[i] * 100.0) / nbuckets,
9416 (nzero_counts * 100.0) / nsyms);
9417 }
9418 }
9419
9420 free (counts);
9421 free (lengths);
9422 }
9423
9424 if (buckets != NULL)
9425 {
9426 free (buckets);
9427 free (chains);
9428 }
9429
9430 if (do_histogram && gnubuckets != NULL)
9431 {
9432 unsigned long * lengths;
9433 unsigned long * counts;
9434 unsigned long hn;
9435 unsigned long maxlength = 0;
9436 unsigned long nzero_counts = 0;
9437 unsigned long nsyms = 0;
9438
9439 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
9440 if (lengths == NULL)
9441 {
9442 error (_("Out of memory\n"));
9443 return 0;
9444 }
9445
9446 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9447 (unsigned long) ngnubuckets);
9448 printf (_(" Length Number %% of total Coverage\n"));
9449
9450 for (hn = 0; hn < ngnubuckets; ++hn)
9451 if (gnubuckets[hn] != 0)
9452 {
9453 bfd_vma off, length = 1;
9454
9455 for (off = gnubuckets[hn] - gnusymidx;
9456 (gnuchains[off] & 1) == 0; ++off)
9457 ++length;
9458 lengths[hn] = length;
9459 if (length > maxlength)
9460 maxlength = length;
9461 nsyms += length;
9462 }
9463
9464 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
9465 if (counts == NULL)
9466 {
9467 error (_("Out of memory\n"));
9468 return 0;
9469 }
9470
9471 for (hn = 0; hn < ngnubuckets; ++hn)
9472 ++counts[lengths[hn]];
9473
9474 if (ngnubuckets > 0)
9475 {
9476 unsigned long j;
9477 printf (" 0 %-10lu (%5.1f%%)\n",
9478 counts[0], (counts[0] * 100.0) / ngnubuckets);
9479 for (j = 1; j <= maxlength; ++j)
9480 {
9481 nzero_counts += counts[j] * j;
9482 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9483 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
9484 (nzero_counts * 100.0) / nsyms);
9485 }
9486 }
9487
9488 free (counts);
9489 free (lengths);
9490 free (gnubuckets);
9491 free (gnuchains);
9492 }
9493
9494 return 1;
9495 }
9496
9497 static int
9498 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
9499 {
9500 unsigned int i;
9501
9502 if (dynamic_syminfo == NULL
9503 || !do_dynamic)
9504 /* No syminfo, this is ok. */
9505 return 1;
9506
9507 /* There better should be a dynamic symbol section. */
9508 if (dynamic_symbols == NULL || dynamic_strings == NULL)
9509 return 0;
9510
9511 if (dynamic_addr)
9512 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9513 dynamic_syminfo_offset, dynamic_syminfo_nent);
9514
9515 printf (_(" Num: Name BoundTo Flags\n"));
9516 for (i = 0; i < dynamic_syminfo_nent; ++i)
9517 {
9518 unsigned short int flags = dynamic_syminfo[i].si_flags;
9519
9520 printf ("%4d: ", i);
9521 if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
9522 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
9523 else
9524 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
9525 putchar (' ');
9526
9527 switch (dynamic_syminfo[i].si_boundto)
9528 {
9529 case SYMINFO_BT_SELF:
9530 fputs ("SELF ", stdout);
9531 break;
9532 case SYMINFO_BT_PARENT:
9533 fputs ("PARENT ", stdout);
9534 break;
9535 default:
9536 if (dynamic_syminfo[i].si_boundto > 0
9537 && dynamic_syminfo[i].si_boundto < dynamic_nent
9538 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
9539 {
9540 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
9541 putchar (' ' );
9542 }
9543 else
9544 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
9545 break;
9546 }
9547
9548 if (flags & SYMINFO_FLG_DIRECT)
9549 printf (" DIRECT");
9550 if (flags & SYMINFO_FLG_PASSTHRU)
9551 printf (" PASSTHRU");
9552 if (flags & SYMINFO_FLG_COPY)
9553 printf (" COPY");
9554 if (flags & SYMINFO_FLG_LAZYLOAD)
9555 printf (" LAZYLOAD");
9556
9557 puts ("");
9558 }
9559
9560 return 1;
9561 }
9562
9563 /* Check to see if the given reloc needs to be handled in a target specific
9564 manner. If so then process the reloc and return TRUE otherwise return
9565 FALSE. */
9566
9567 static bfd_boolean
9568 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
9569 unsigned char * start,
9570 Elf_Internal_Sym * symtab)
9571 {
9572 unsigned int reloc_type = get_reloc_type (reloc->r_info);
9573
9574 switch (elf_header.e_machine)
9575 {
9576 case EM_MN10300:
9577 case EM_CYGNUS_MN10300:
9578 {
9579 static Elf_Internal_Sym * saved_sym = NULL;
9580
9581 switch (reloc_type)
9582 {
9583 case 34: /* R_MN10300_ALIGN */
9584 return TRUE;
9585 case 33: /* R_MN10300_SYM_DIFF */
9586 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
9587 return TRUE;
9588 case 1: /* R_MN10300_32 */
9589 case 2: /* R_MN10300_16 */
9590 if (saved_sym != NULL)
9591 {
9592 bfd_vma value;
9593
9594 value = reloc->r_addend
9595 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
9596 - saved_sym->st_value);
9597
9598 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
9599
9600 saved_sym = NULL;
9601 return TRUE;
9602 }
9603 break;
9604 default:
9605 if (saved_sym != NULL)
9606 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
9607 break;
9608 }
9609 break;
9610 }
9611 }
9612
9613 return FALSE;
9614 }
9615
9616 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
9617 DWARF debug sections. This is a target specific test. Note - we do not
9618 go through the whole including-target-headers-multiple-times route, (as
9619 we have already done with <elf/h8.h>) because this would become very
9620 messy and even then this function would have to contain target specific
9621 information (the names of the relocs instead of their numeric values).
9622 FIXME: This is not the correct way to solve this problem. The proper way
9623 is to have target specific reloc sizing and typing functions created by
9624 the reloc-macros.h header, in the same way that it already creates the
9625 reloc naming functions. */
9626
9627 static bfd_boolean
9628 is_32bit_abs_reloc (unsigned int reloc_type)
9629 {
9630 switch (elf_header.e_machine)
9631 {
9632 case EM_386:
9633 case EM_486:
9634 return reloc_type == 1; /* R_386_32. */
9635 case EM_68K:
9636 return reloc_type == 1; /* R_68K_32. */
9637 case EM_860:
9638 return reloc_type == 1; /* R_860_32. */
9639 case EM_960:
9640 return reloc_type == 2; /* R_960_32. */
9641 case EM_ALPHA:
9642 return reloc_type == 1; /* R_ALPHA_REFLONG. */
9643 case EM_ARC:
9644 return reloc_type == 1; /* R_ARC_32. */
9645 case EM_ARM:
9646 return reloc_type == 2; /* R_ARM_ABS32 */
9647 case EM_AVR_OLD:
9648 case EM_AVR:
9649 return reloc_type == 1;
9650 case EM_BLACKFIN:
9651 return reloc_type == 0x12; /* R_byte4_data. */
9652 case EM_CRIS:
9653 return reloc_type == 3; /* R_CRIS_32. */
9654 case EM_CR16:
9655 case EM_CR16_OLD:
9656 return reloc_type == 3; /* R_CR16_NUM32. */
9657 case EM_CRX:
9658 return reloc_type == 15; /* R_CRX_NUM32. */
9659 case EM_CYGNUS_FRV:
9660 return reloc_type == 1;
9661 case EM_CYGNUS_D10V:
9662 case EM_D10V:
9663 return reloc_type == 6; /* R_D10V_32. */
9664 case EM_CYGNUS_D30V:
9665 case EM_D30V:
9666 return reloc_type == 12; /* R_D30V_32_NORMAL. */
9667 case EM_DLX:
9668 return reloc_type == 3; /* R_DLX_RELOC_32. */
9669 case EM_CYGNUS_FR30:
9670 case EM_FR30:
9671 return reloc_type == 3; /* R_FR30_32. */
9672 case EM_H8S:
9673 case EM_H8_300:
9674 case EM_H8_300H:
9675 return reloc_type == 1; /* R_H8_DIR32. */
9676 case EM_IA_64:
9677 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
9678 case EM_IP2K_OLD:
9679 case EM_IP2K:
9680 return reloc_type == 2; /* R_IP2K_32. */
9681 case EM_IQ2000:
9682 return reloc_type == 2; /* R_IQ2000_32. */
9683 case EM_LATTICEMICO32:
9684 return reloc_type == 3; /* R_LM32_32. */
9685 case EM_M32C_OLD:
9686 case EM_M32C:
9687 return reloc_type == 3; /* R_M32C_32. */
9688 case EM_M32R:
9689 return reloc_type == 34; /* R_M32R_32_RELA. */
9690 case EM_MCORE:
9691 return reloc_type == 1; /* R_MCORE_ADDR32. */
9692 case EM_CYGNUS_MEP:
9693 return reloc_type == 4; /* R_MEP_32. */
9694 case EM_MICROBLAZE:
9695 return reloc_type == 1; /* R_MICROBLAZE_32. */
9696 case EM_MIPS:
9697 return reloc_type == 2; /* R_MIPS_32. */
9698 case EM_MMIX:
9699 return reloc_type == 4; /* R_MMIX_32. */
9700 case EM_CYGNUS_MN10200:
9701 case EM_MN10200:
9702 return reloc_type == 1; /* R_MN10200_32. */
9703 case EM_CYGNUS_MN10300:
9704 case EM_MN10300:
9705 return reloc_type == 1; /* R_MN10300_32. */
9706 case EM_MOXIE:
9707 return reloc_type == 1; /* R_MOXIE_32. */
9708 case EM_MSP430_OLD:
9709 case EM_MSP430:
9710 return reloc_type == 1; /* R_MSP43_32. */
9711 case EM_MT:
9712 return reloc_type == 2; /* R_MT_32. */
9713 case EM_ALTERA_NIOS2:
9714 case EM_NIOS32:
9715 return reloc_type == 1; /* R_NIOS_32. */
9716 case EM_OPENRISC:
9717 case EM_OR32:
9718 return reloc_type == 1; /* R_OR32_32. */
9719 case EM_PARISC:
9720 return (reloc_type == 1 /* R_PARISC_DIR32. */
9721 || reloc_type == 41); /* R_PARISC_SECREL32. */
9722 case EM_PJ:
9723 case EM_PJ_OLD:
9724 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
9725 case EM_PPC64:
9726 return reloc_type == 1; /* R_PPC64_ADDR32. */
9727 case EM_PPC:
9728 return reloc_type == 1; /* R_PPC_ADDR32. */
9729 case EM_RX:
9730 return reloc_type == 1; /* R_RX_DIR32. */
9731 case EM_S370:
9732 return reloc_type == 1; /* R_I370_ADDR31. */
9733 case EM_S390_OLD:
9734 case EM_S390:
9735 return reloc_type == 4; /* R_S390_32. */
9736 case EM_SCORE:
9737 return reloc_type == 8; /* R_SCORE_ABS32. */
9738 case EM_SH:
9739 return reloc_type == 1; /* R_SH_DIR32. */
9740 case EM_SPARC32PLUS:
9741 case EM_SPARCV9:
9742 case EM_SPARC:
9743 return reloc_type == 3 /* R_SPARC_32. */
9744 || reloc_type == 23; /* R_SPARC_UA32. */
9745 case EM_SPU:
9746 return reloc_type == 6; /* R_SPU_ADDR32 */
9747 case EM_TI_C6000:
9748 return reloc_type == 1; /* R_C6000_ABS32. */
9749 case EM_TILEGX:
9750 return reloc_type == 2; /* R_TILEGX_32. */
9751 case EM_TILEPRO:
9752 return reloc_type == 1; /* R_TILEPRO_32. */
9753 case EM_CYGNUS_V850:
9754 case EM_V850:
9755 return reloc_type == 6; /* R_V850_ABS32. */
9756 case EM_VAX:
9757 return reloc_type == 1; /* R_VAX_32. */
9758 case EM_X86_64:
9759 case EM_L1OM:
9760 return reloc_type == 10; /* R_X86_64_32. */
9761 case EM_XC16X:
9762 case EM_C166:
9763 return reloc_type == 3; /* R_XC16C_ABS_32. */
9764 case EM_XSTORMY16:
9765 return reloc_type == 1; /* R_XSTROMY16_32. */
9766 case EM_XTENSA_OLD:
9767 case EM_XTENSA:
9768 return reloc_type == 1; /* R_XTENSA_32. */
9769 default:
9770 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
9771 elf_header.e_machine);
9772 abort ();
9773 }
9774 }
9775
9776 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9777 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
9778
9779 static bfd_boolean
9780 is_32bit_pcrel_reloc (unsigned int reloc_type)
9781 {
9782 switch (elf_header.e_machine)
9783 {
9784 case EM_386:
9785 case EM_486:
9786 return reloc_type == 2; /* R_386_PC32. */
9787 case EM_68K:
9788 return reloc_type == 4; /* R_68K_PC32. */
9789 case EM_ALPHA:
9790 return reloc_type == 10; /* R_ALPHA_SREL32. */
9791 case EM_ARM:
9792 return reloc_type == 3; /* R_ARM_REL32 */
9793 case EM_MICROBLAZE:
9794 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
9795 case EM_PARISC:
9796 return reloc_type == 9; /* R_PARISC_PCREL32. */
9797 case EM_PPC:
9798 return reloc_type == 26; /* R_PPC_REL32. */
9799 case EM_PPC64:
9800 return reloc_type == 26; /* R_PPC64_REL32. */
9801 case EM_S390_OLD:
9802 case EM_S390:
9803 return reloc_type == 5; /* R_390_PC32. */
9804 case EM_SH:
9805 return reloc_type == 2; /* R_SH_REL32. */
9806 case EM_SPARC32PLUS:
9807 case EM_SPARCV9:
9808 case EM_SPARC:
9809 return reloc_type == 6; /* R_SPARC_DISP32. */
9810 case EM_SPU:
9811 return reloc_type == 13; /* R_SPU_REL32. */
9812 case EM_TILEGX:
9813 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
9814 case EM_TILEPRO:
9815 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
9816 case EM_X86_64:
9817 case EM_L1OM:
9818 return reloc_type == 2; /* R_X86_64_PC32. */
9819 case EM_XTENSA_OLD:
9820 case EM_XTENSA:
9821 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
9822 default:
9823 /* Do not abort or issue an error message here. Not all targets use
9824 pc-relative 32-bit relocs in their DWARF debug information and we
9825 have already tested for target coverage in is_32bit_abs_reloc. A
9826 more helpful warning message will be generated by apply_relocations
9827 anyway, so just return. */
9828 return FALSE;
9829 }
9830 }
9831
9832 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9833 a 64-bit absolute RELA relocation used in DWARF debug sections. */
9834
9835 static bfd_boolean
9836 is_64bit_abs_reloc (unsigned int reloc_type)
9837 {
9838 switch (elf_header.e_machine)
9839 {
9840 case EM_ALPHA:
9841 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
9842 case EM_IA_64:
9843 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
9844 case EM_PARISC:
9845 return reloc_type == 80; /* R_PARISC_DIR64. */
9846 case EM_PPC64:
9847 return reloc_type == 38; /* R_PPC64_ADDR64. */
9848 case EM_SPARC32PLUS:
9849 case EM_SPARCV9:
9850 case EM_SPARC:
9851 return reloc_type == 54; /* R_SPARC_UA64. */
9852 case EM_X86_64:
9853 case EM_L1OM:
9854 return reloc_type == 1; /* R_X86_64_64. */
9855 case EM_S390_OLD:
9856 case EM_S390:
9857 return reloc_type == 22; /* R_S390_64. */
9858 case EM_TILEGX:
9859 return reloc_type == 1; /* R_TILEGX_64. */
9860 case EM_MIPS:
9861 return reloc_type == 18; /* R_MIPS_64. */
9862 default:
9863 return FALSE;
9864 }
9865 }
9866
9867 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
9868 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
9869
9870 static bfd_boolean
9871 is_64bit_pcrel_reloc (unsigned int reloc_type)
9872 {
9873 switch (elf_header.e_machine)
9874 {
9875 case EM_ALPHA:
9876 return reloc_type == 11; /* R_ALPHA_SREL64. */
9877 case EM_IA_64:
9878 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
9879 case EM_PARISC:
9880 return reloc_type == 72; /* R_PARISC_PCREL64. */
9881 case EM_PPC64:
9882 return reloc_type == 44; /* R_PPC64_REL64. */
9883 case EM_SPARC32PLUS:
9884 case EM_SPARCV9:
9885 case EM_SPARC:
9886 return reloc_type == 46; /* R_SPARC_DISP64. */
9887 case EM_X86_64:
9888 case EM_L1OM:
9889 return reloc_type == 24; /* R_X86_64_PC64. */
9890 case EM_S390_OLD:
9891 case EM_S390:
9892 return reloc_type == 23; /* R_S390_PC64. */
9893 case EM_TILEGX:
9894 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
9895 default:
9896 return FALSE;
9897 }
9898 }
9899
9900 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9901 a 24-bit absolute RELA relocation used in DWARF debug sections. */
9902
9903 static bfd_boolean
9904 is_24bit_abs_reloc (unsigned int reloc_type)
9905 {
9906 switch (elf_header.e_machine)
9907 {
9908 case EM_CYGNUS_MN10200:
9909 case EM_MN10200:
9910 return reloc_type == 4; /* R_MN10200_24. */
9911 default:
9912 return FALSE;
9913 }
9914 }
9915
9916 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9917 a 16-bit absolute RELA relocation used in DWARF debug sections. */
9918
9919 static bfd_boolean
9920 is_16bit_abs_reloc (unsigned int reloc_type)
9921 {
9922 switch (elf_header.e_machine)
9923 {
9924 case EM_AVR_OLD:
9925 case EM_AVR:
9926 return reloc_type == 4; /* R_AVR_16. */
9927 case EM_CYGNUS_D10V:
9928 case EM_D10V:
9929 return reloc_type == 3; /* R_D10V_16. */
9930 case EM_H8S:
9931 case EM_H8_300:
9932 case EM_H8_300H:
9933 return reloc_type == R_H8_DIR16;
9934 case EM_IP2K_OLD:
9935 case EM_IP2K:
9936 return reloc_type == 1; /* R_IP2K_16. */
9937 case EM_M32C_OLD:
9938 case EM_M32C:
9939 return reloc_type == 1; /* R_M32C_16 */
9940 case EM_MSP430_OLD:
9941 case EM_MSP430:
9942 return reloc_type == 5; /* R_MSP430_16_BYTE. */
9943 case EM_ALTERA_NIOS2:
9944 case EM_NIOS32:
9945 return reloc_type == 9; /* R_NIOS_16. */
9946 case EM_TI_C6000:
9947 return reloc_type == 2; /* R_C6000_ABS16. */
9948 case EM_XC16X:
9949 case EM_C166:
9950 return reloc_type == 2; /* R_XC16C_ABS_16. */
9951 default:
9952 return FALSE;
9953 }
9954 }
9955
9956 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
9957 relocation entries (possibly formerly used for SHT_GROUP sections). */
9958
9959 static bfd_boolean
9960 is_none_reloc (unsigned int reloc_type)
9961 {
9962 switch (elf_header.e_machine)
9963 {
9964 case EM_68K: /* R_68K_NONE. */
9965 case EM_386: /* R_386_NONE. */
9966 case EM_SPARC32PLUS:
9967 case EM_SPARCV9:
9968 case EM_SPARC: /* R_SPARC_NONE. */
9969 case EM_MIPS: /* R_MIPS_NONE. */
9970 case EM_PARISC: /* R_PARISC_NONE. */
9971 case EM_ALPHA: /* R_ALPHA_NONE. */
9972 case EM_PPC: /* R_PPC_NONE. */
9973 case EM_PPC64: /* R_PPC64_NONE. */
9974 case EM_ARM: /* R_ARM_NONE. */
9975 case EM_IA_64: /* R_IA64_NONE. */
9976 case EM_SH: /* R_SH_NONE. */
9977 case EM_S390_OLD:
9978 case EM_S390: /* R_390_NONE. */
9979 case EM_CRIS: /* R_CRIS_NONE. */
9980 case EM_X86_64: /* R_X86_64_NONE. */
9981 case EM_L1OM: /* R_X86_64_NONE. */
9982 case EM_MN10300: /* R_MN10300_NONE. */
9983 case EM_MOXIE: /* R_MOXIE_NONE. */
9984 case EM_M32R: /* R_M32R_NONE. */
9985 case EM_TI_C6000:/* R_C6000_NONE. */
9986 case EM_TILEGX: /* R_TILEGX_NONE. */
9987 case EM_TILEPRO: /* R_TILEPRO_NONE. */
9988 case EM_XC16X:
9989 case EM_C166: /* R_XC16X_NONE. */
9990 return reloc_type == 0;
9991 case EM_XTENSA_OLD:
9992 case EM_XTENSA:
9993 return (reloc_type == 0 /* R_XTENSA_NONE. */
9994 || reloc_type == 17 /* R_XTENSA_DIFF8. */
9995 || reloc_type == 18 /* R_XTENSA_DIFF16. */
9996 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
9997 }
9998 return FALSE;
9999 }
10000
10001 /* Apply relocations to a section.
10002 Note: So far support has been added only for those relocations
10003 which can be found in debug sections.
10004 FIXME: Add support for more relocations ? */
10005
10006 static void
10007 apply_relocations (void * file,
10008 Elf_Internal_Shdr * section,
10009 unsigned char * start)
10010 {
10011 Elf_Internal_Shdr * relsec;
10012 unsigned char * end = start + section->sh_size;
10013
10014 if (elf_header.e_type != ET_REL)
10015 return;
10016
10017 /* Find the reloc section associated with the section. */
10018 for (relsec = section_headers;
10019 relsec < section_headers + elf_header.e_shnum;
10020 ++relsec)
10021 {
10022 bfd_boolean is_rela;
10023 unsigned long num_relocs;
10024 Elf_Internal_Rela * relocs;
10025 Elf_Internal_Rela * rp;
10026 Elf_Internal_Shdr * symsec;
10027 Elf_Internal_Sym * symtab;
10028 Elf_Internal_Sym * sym;
10029
10030 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10031 || relsec->sh_info >= elf_header.e_shnum
10032 || section_headers + relsec->sh_info != section
10033 || relsec->sh_size == 0
10034 || relsec->sh_link >= elf_header.e_shnum)
10035 continue;
10036
10037 is_rela = relsec->sh_type == SHT_RELA;
10038
10039 if (is_rela)
10040 {
10041 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
10042 relsec->sh_size, & relocs, & num_relocs))
10043 return;
10044 }
10045 else
10046 {
10047 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
10048 relsec->sh_size, & relocs, & num_relocs))
10049 return;
10050 }
10051
10052 /* SH uses RELA but uses in place value instead of the addend field. */
10053 if (elf_header.e_machine == EM_SH)
10054 is_rela = FALSE;
10055
10056 symsec = section_headers + relsec->sh_link;
10057 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec);
10058
10059 for (rp = relocs; rp < relocs + num_relocs; ++rp)
10060 {
10061 bfd_vma addend;
10062 unsigned int reloc_type;
10063 unsigned int reloc_size;
10064 unsigned char * rloc;
10065
10066 reloc_type = get_reloc_type (rp->r_info);
10067
10068 if (target_specific_reloc_handling (rp, start, symtab))
10069 continue;
10070 else if (is_none_reloc (reloc_type))
10071 continue;
10072 else if (is_32bit_abs_reloc (reloc_type)
10073 || is_32bit_pcrel_reloc (reloc_type))
10074 reloc_size = 4;
10075 else if (is_64bit_abs_reloc (reloc_type)
10076 || is_64bit_pcrel_reloc (reloc_type))
10077 reloc_size = 8;
10078 else if (is_24bit_abs_reloc (reloc_type))
10079 reloc_size = 3;
10080 else if (is_16bit_abs_reloc (reloc_type))
10081 reloc_size = 2;
10082 else
10083 {
10084 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
10085 reloc_type, SECTION_NAME (section));
10086 continue;
10087 }
10088
10089 rloc = start + rp->r_offset;
10090 if ((rloc + reloc_size) > end)
10091 {
10092 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10093 (unsigned long) rp->r_offset,
10094 SECTION_NAME (section));
10095 continue;
10096 }
10097
10098 sym = symtab + get_reloc_symindex (rp->r_info);
10099
10100 /* If the reloc has a symbol associated with it,
10101 make sure that it is of an appropriate type.
10102
10103 Relocations against symbols without type can happen.
10104 Gcc -feliminate-dwarf2-dups may generate symbols
10105 without type for debug info.
10106
10107 Icc generates relocations against function symbols
10108 instead of local labels.
10109
10110 Relocations against object symbols can happen, eg when
10111 referencing a global array. For an example of this see
10112 the _clz.o binary in libgcc.a. */
10113 if (sym != symtab
10114 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
10115 {
10116 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
10117 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
10118 (long int)(rp - relocs),
10119 SECTION_NAME (relsec));
10120 continue;
10121 }
10122
10123 addend = 0;
10124 if (is_rela)
10125 addend += rp->r_addend;
10126 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10127 partial_inplace. */
10128 if (!is_rela
10129 || (elf_header.e_machine == EM_XTENSA
10130 && reloc_type == 1)
10131 || ((elf_header.e_machine == EM_PJ
10132 || elf_header.e_machine == EM_PJ_OLD)
10133 && reloc_type == 1)
10134 || ((elf_header.e_machine == EM_D30V
10135 || elf_header.e_machine == EM_CYGNUS_D30V)
10136 && reloc_type == 12))
10137 addend += byte_get (rloc, reloc_size);
10138
10139 if (is_32bit_pcrel_reloc (reloc_type)
10140 || is_64bit_pcrel_reloc (reloc_type))
10141 {
10142 /* On HPPA, all pc-relative relocations are biased by 8. */
10143 if (elf_header.e_machine == EM_PARISC)
10144 addend -= 8;
10145 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
10146 reloc_size);
10147 }
10148 else
10149 byte_put (rloc, addend + sym->st_value, reloc_size);
10150 }
10151
10152 free (symtab);
10153 free (relocs);
10154 break;
10155 }
10156 }
10157
10158 #ifdef SUPPORT_DISASSEMBLY
10159 static int
10160 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
10161 {
10162 printf (_("\nAssembly dump of section %s\n"),
10163 SECTION_NAME (section));
10164
10165 /* XXX -- to be done --- XXX */
10166
10167 return 1;
10168 }
10169 #endif
10170
10171 /* Reads in the contents of SECTION from FILE, returning a pointer
10172 to a malloc'ed buffer or NULL if something went wrong. */
10173
10174 static char *
10175 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
10176 {
10177 bfd_size_type num_bytes;
10178
10179 num_bytes = section->sh_size;
10180
10181 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
10182 {
10183 printf (_("\nSection '%s' has no data to dump.\n"),
10184 SECTION_NAME (section));
10185 return NULL;
10186 }
10187
10188 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
10189 _("section contents"));
10190 }
10191
10192
10193 static void
10194 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
10195 {
10196 Elf_Internal_Shdr * relsec;
10197 bfd_size_type num_bytes;
10198 char * data;
10199 char * end;
10200 char * start;
10201 char * name = SECTION_NAME (section);
10202 bfd_boolean some_strings_shown;
10203
10204 start = get_section_contents (section, file);
10205 if (start == NULL)
10206 return;
10207
10208 printf (_("\nString dump of section '%s':\n"), name);
10209
10210 /* If the section being dumped has relocations against it the user might
10211 be expecting these relocations to have been applied. Check for this
10212 case and issue a warning message in order to avoid confusion.
10213 FIXME: Maybe we ought to have an option that dumps a section with
10214 relocs applied ? */
10215 for (relsec = section_headers;
10216 relsec < section_headers + elf_header.e_shnum;
10217 ++relsec)
10218 {
10219 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10220 || relsec->sh_info >= elf_header.e_shnum
10221 || section_headers + relsec->sh_info != section
10222 || relsec->sh_size == 0
10223 || relsec->sh_link >= elf_header.e_shnum)
10224 continue;
10225
10226 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10227 break;
10228 }
10229
10230 num_bytes = section->sh_size;
10231 data = start;
10232 end = start + num_bytes;
10233 some_strings_shown = FALSE;
10234
10235 while (data < end)
10236 {
10237 while (!ISPRINT (* data))
10238 if (++ data >= end)
10239 break;
10240
10241 if (data < end)
10242 {
10243 #ifndef __MSVCRT__
10244 /* PR 11128: Use two separate invocations in order to work
10245 around bugs in the Solaris 8 implementation of printf. */
10246 printf (" [%6tx] ", data - start);
10247 printf ("%s\n", data);
10248 #else
10249 printf (" [%6Ix] %s\n", (size_t) (data - start), data);
10250 #endif
10251 data += strlen (data);
10252 some_strings_shown = TRUE;
10253 }
10254 }
10255
10256 if (! some_strings_shown)
10257 printf (_(" No strings found in this section."));
10258
10259 free (start);
10260
10261 putchar ('\n');
10262 }
10263
10264 static void
10265 dump_section_as_bytes (Elf_Internal_Shdr * section,
10266 FILE * file,
10267 bfd_boolean relocate)
10268 {
10269 Elf_Internal_Shdr * relsec;
10270 bfd_size_type bytes;
10271 bfd_vma addr;
10272 unsigned char * data;
10273 unsigned char * start;
10274
10275 start = (unsigned char *) get_section_contents (section, file);
10276 if (start == NULL)
10277 return;
10278
10279 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
10280
10281 if (relocate)
10282 {
10283 apply_relocations (file, section, start);
10284 }
10285 else
10286 {
10287 /* If the section being dumped has relocations against it the user might
10288 be expecting these relocations to have been applied. Check for this
10289 case and issue a warning message in order to avoid confusion.
10290 FIXME: Maybe we ought to have an option that dumps a section with
10291 relocs applied ? */
10292 for (relsec = section_headers;
10293 relsec < section_headers + elf_header.e_shnum;
10294 ++relsec)
10295 {
10296 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10297 || relsec->sh_info >= elf_header.e_shnum
10298 || section_headers + relsec->sh_info != section
10299 || relsec->sh_size == 0
10300 || relsec->sh_link >= elf_header.e_shnum)
10301 continue;
10302
10303 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10304 break;
10305 }
10306 }
10307
10308 addr = section->sh_addr;
10309 bytes = section->sh_size;
10310 data = start;
10311
10312 while (bytes)
10313 {
10314 int j;
10315 int k;
10316 int lbytes;
10317
10318 lbytes = (bytes > 16 ? 16 : bytes);
10319
10320 printf (" 0x%8.8lx ", (unsigned long) addr);
10321
10322 for (j = 0; j < 16; j++)
10323 {
10324 if (j < lbytes)
10325 printf ("%2.2x", data[j]);
10326 else
10327 printf (" ");
10328
10329 if ((j & 3) == 3)
10330 printf (" ");
10331 }
10332
10333 for (j = 0; j < lbytes; j++)
10334 {
10335 k = data[j];
10336 if (k >= ' ' && k < 0x7f)
10337 printf ("%c", k);
10338 else
10339 printf (".");
10340 }
10341
10342 putchar ('\n');
10343
10344 data += lbytes;
10345 addr += lbytes;
10346 bytes -= lbytes;
10347 }
10348
10349 free (start);
10350
10351 putchar ('\n');
10352 }
10353
10354 /* Uncompresses a section that was compressed using zlib, in place. */
10355
10356 static int
10357 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
10358 dwarf_size_type *size ATTRIBUTE_UNUSED)
10359 {
10360 #ifndef HAVE_ZLIB_H
10361 return FALSE;
10362 #else
10363 dwarf_size_type compressed_size = *size;
10364 unsigned char * compressed_buffer = *buffer;
10365 dwarf_size_type uncompressed_size;
10366 unsigned char * uncompressed_buffer;
10367 z_stream strm;
10368 int rc;
10369 dwarf_size_type header_size = 12;
10370
10371 /* Read the zlib header. In this case, it should be "ZLIB" followed
10372 by the uncompressed section size, 8 bytes in big-endian order. */
10373 if (compressed_size < header_size
10374 || ! streq ((char *) compressed_buffer, "ZLIB"))
10375 return 0;
10376
10377 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
10378 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
10379 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
10380 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
10381 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
10382 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
10383 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
10384 uncompressed_size += compressed_buffer[11];
10385
10386 /* It is possible the section consists of several compressed
10387 buffers concatenated together, so we uncompress in a loop. */
10388 strm.zalloc = NULL;
10389 strm.zfree = NULL;
10390 strm.opaque = NULL;
10391 strm.avail_in = compressed_size - header_size;
10392 strm.next_in = (Bytef *) compressed_buffer + header_size;
10393 strm.avail_out = uncompressed_size;
10394 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
10395
10396 rc = inflateInit (& strm);
10397 while (strm.avail_in > 0)
10398 {
10399 if (rc != Z_OK)
10400 goto fail;
10401 strm.next_out = ((Bytef *) uncompressed_buffer
10402 + (uncompressed_size - strm.avail_out));
10403 rc = inflate (&strm, Z_FINISH);
10404 if (rc != Z_STREAM_END)
10405 goto fail;
10406 rc = inflateReset (& strm);
10407 }
10408 rc = inflateEnd (& strm);
10409 if (rc != Z_OK
10410 || strm.avail_out != 0)
10411 goto fail;
10412
10413 free (compressed_buffer);
10414 *buffer = uncompressed_buffer;
10415 *size = uncompressed_size;
10416 return 1;
10417
10418 fail:
10419 free (uncompressed_buffer);
10420 /* Indicate decompression failure. */
10421 *buffer = NULL;
10422 return 0;
10423 #endif /* HAVE_ZLIB_H */
10424 }
10425
10426 static int
10427 load_specific_debug_section (enum dwarf_section_display_enum debug,
10428 Elf_Internal_Shdr * sec, void * file)
10429 {
10430 struct dwarf_section * section = &debug_displays [debug].section;
10431 char buf [64];
10432
10433 /* If it is already loaded, do nothing. */
10434 if (section->start != NULL)
10435 return 1;
10436
10437 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
10438 section->address = sec->sh_addr;
10439 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
10440 sec->sh_offset, 1,
10441 sec->sh_size, buf);
10442 if (section->start == NULL)
10443 section->size = 0;
10444 else
10445 {
10446 section->size = sec->sh_size;
10447 if (uncompress_section_contents (&section->start, &section->size))
10448 sec->sh_size = section->size;
10449 }
10450
10451 if (section->start == NULL)
10452 return 0;
10453
10454 if (debug_displays [debug].relocate)
10455 apply_relocations ((FILE *) file, sec, section->start);
10456
10457 return 1;
10458 }
10459
10460 int
10461 load_debug_section (enum dwarf_section_display_enum debug, void * file)
10462 {
10463 struct dwarf_section * section = &debug_displays [debug].section;
10464 Elf_Internal_Shdr * sec;
10465
10466 /* Locate the debug section. */
10467 sec = find_section (section->uncompressed_name);
10468 if (sec != NULL)
10469 section->name = section->uncompressed_name;
10470 else
10471 {
10472 sec = find_section (section->compressed_name);
10473 if (sec != NULL)
10474 section->name = section->compressed_name;
10475 }
10476 if (sec == NULL)
10477 return 0;
10478
10479 return load_specific_debug_section (debug, sec, (FILE *) file);
10480 }
10481
10482 void
10483 free_debug_section (enum dwarf_section_display_enum debug)
10484 {
10485 struct dwarf_section * section = &debug_displays [debug].section;
10486
10487 if (section->start == NULL)
10488 return;
10489
10490 free ((char *) section->start);
10491 section->start = NULL;
10492 section->address = 0;
10493 section->size = 0;
10494 }
10495
10496 static int
10497 display_debug_section (Elf_Internal_Shdr * section, FILE * file)
10498 {
10499 char * name = SECTION_NAME (section);
10500 bfd_size_type length;
10501 int result = 1;
10502 int i;
10503
10504 length = section->sh_size;
10505 if (length == 0)
10506 {
10507 printf (_("\nSection '%s' has no debugging data.\n"), name);
10508 return 0;
10509 }
10510 if (section->sh_type == SHT_NOBITS)
10511 {
10512 /* There is no point in dumping the contents of a debugging section
10513 which has the NOBITS type - the bits in the file will be random.
10514 This can happen when a file containing a .eh_frame section is
10515 stripped with the --only-keep-debug command line option. */
10516 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
10517 return 0;
10518 }
10519
10520 if (const_strneq (name, ".gnu.linkonce.wi."))
10521 name = ".debug_info";
10522
10523 /* See if we know how to display the contents of this section. */
10524 for (i = 0; i < max; i++)
10525 if (streq (debug_displays[i].section.uncompressed_name, name)
10526 || streq (debug_displays[i].section.compressed_name, name))
10527 {
10528 struct dwarf_section * sec = &debug_displays [i].section;
10529 int secondary = (section != find_section (name));
10530
10531 if (secondary)
10532 free_debug_section ((enum dwarf_section_display_enum) i);
10533
10534 if (streq (sec->uncompressed_name, name))
10535 sec->name = sec->uncompressed_name;
10536 else
10537 sec->name = sec->compressed_name;
10538 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
10539 section, file))
10540 {
10541 result &= debug_displays[i].display (sec, file);
10542
10543 if (secondary || (i != info && i != abbrev))
10544 free_debug_section ((enum dwarf_section_display_enum) i);
10545 }
10546
10547 break;
10548 }
10549
10550 if (i == max)
10551 {
10552 printf (_("Unrecognized debug section: %s\n"), name);
10553 result = 0;
10554 }
10555
10556 return result;
10557 }
10558
10559 /* Set DUMP_SECTS for all sections where dumps were requested
10560 based on section name. */
10561
10562 static void
10563 initialise_dumps_byname (void)
10564 {
10565 struct dump_list_entry * cur;
10566
10567 for (cur = dump_sects_byname; cur; cur = cur->next)
10568 {
10569 unsigned int i;
10570 int any;
10571
10572 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
10573 if (streq (SECTION_NAME (section_headers + i), cur->name))
10574 {
10575 request_dump_bynumber (i, cur->type);
10576 any = 1;
10577 }
10578
10579 if (!any)
10580 warn (_("Section '%s' was not dumped because it does not exist!\n"),
10581 cur->name);
10582 }
10583 }
10584
10585 static void
10586 process_section_contents (FILE * file)
10587 {
10588 Elf_Internal_Shdr * section;
10589 unsigned int i;
10590
10591 if (! do_dump)
10592 return;
10593
10594 initialise_dumps_byname ();
10595
10596 for (i = 0, section = section_headers;
10597 i < elf_header.e_shnum && i < num_dump_sects;
10598 i++, section++)
10599 {
10600 #ifdef SUPPORT_DISASSEMBLY
10601 if (dump_sects[i] & DISASS_DUMP)
10602 disassemble_section (section, file);
10603 #endif
10604 if (dump_sects[i] & HEX_DUMP)
10605 dump_section_as_bytes (section, file, FALSE);
10606
10607 if (dump_sects[i] & RELOC_DUMP)
10608 dump_section_as_bytes (section, file, TRUE);
10609
10610 if (dump_sects[i] & STRING_DUMP)
10611 dump_section_as_strings (section, file);
10612
10613 if (dump_sects[i] & DEBUG_DUMP)
10614 display_debug_section (section, file);
10615 }
10616
10617 /* Check to see if the user requested a
10618 dump of a section that does not exist. */
10619 while (i++ < num_dump_sects)
10620 if (dump_sects[i])
10621 warn (_("Section %d was not dumped because it does not exist!\n"), i);
10622 }
10623
10624 static void
10625 process_mips_fpe_exception (int mask)
10626 {
10627 if (mask)
10628 {
10629 int first = 1;
10630 if (mask & OEX_FPU_INEX)
10631 fputs ("INEX", stdout), first = 0;
10632 if (mask & OEX_FPU_UFLO)
10633 printf ("%sUFLO", first ? "" : "|"), first = 0;
10634 if (mask & OEX_FPU_OFLO)
10635 printf ("%sOFLO", first ? "" : "|"), first = 0;
10636 if (mask & OEX_FPU_DIV0)
10637 printf ("%sDIV0", first ? "" : "|"), first = 0;
10638 if (mask & OEX_FPU_INVAL)
10639 printf ("%sINVAL", first ? "" : "|");
10640 }
10641 else
10642 fputs ("0", stdout);
10643 }
10644
10645 /* ARM EABI attributes section. */
10646 typedef struct
10647 {
10648 int tag;
10649 const char * name;
10650 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
10651 int type;
10652 const char ** table;
10653 } arm_attr_public_tag;
10654
10655 static const char * arm_attr_tag_CPU_arch[] =
10656 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
10657 "v6K", "v7", "v6-M", "v6S-M", "v7E-M"};
10658 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
10659 static const char * arm_attr_tag_THUMB_ISA_use[] =
10660 {"No", "Thumb-1", "Thumb-2"};
10661 static const char * arm_attr_tag_FP_arch[] =
10662 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16"};
10663 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
10664 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
10665 {"No", "NEONv1", "NEONv1 with Fused-MAC"};
10666 static const char * arm_attr_tag_PCS_config[] =
10667 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
10668 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
10669 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
10670 {"V6", "SB", "TLS", "Unused"};
10671 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
10672 {"Absolute", "PC-relative", "SB-relative", "None"};
10673 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
10674 {"Absolute", "PC-relative", "None"};
10675 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
10676 {"None", "direct", "GOT-indirect"};
10677 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
10678 {"None", "??? 1", "2", "??? 3", "4"};
10679 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
10680 static const char * arm_attr_tag_ABI_FP_denormal[] =
10681 {"Unused", "Needed", "Sign only"};
10682 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
10683 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
10684 static const char * arm_attr_tag_ABI_FP_number_model[] =
10685 {"Unused", "Finite", "RTABI", "IEEE 754"};
10686 static const char * arm_attr_tag_ABI_enum_size[] =
10687 {"Unused", "small", "int", "forced to int"};
10688 static const char * arm_attr_tag_ABI_HardFP_use[] =
10689 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
10690 static const char * arm_attr_tag_ABI_VFP_args[] =
10691 {"AAPCS", "VFP registers", "custom"};
10692 static const char * arm_attr_tag_ABI_WMMX_args[] =
10693 {"AAPCS", "WMMX registers", "custom"};
10694 static const char * arm_attr_tag_ABI_optimization_goals[] =
10695 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10696 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
10697 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
10698 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10699 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
10700 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
10701 static const char * arm_attr_tag_FP_HP_extension[] =
10702 {"Not Allowed", "Allowed"};
10703 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
10704 {"None", "IEEE 754", "Alternative Format"};
10705 static const char * arm_attr_tag_MPextension_use[] =
10706 {"Not Allowed", "Allowed"};
10707 static const char * arm_attr_tag_DIV_use[] =
10708 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
10709 "Allowed in v7-A with integer division extension"};
10710 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
10711 static const char * arm_attr_tag_Virtualization_use[] =
10712 {"Not Allowed", "TrustZone", "Virtualization Extensions",
10713 "TrustZone and Virtualization Extensions"};
10714 static const char * arm_attr_tag_MPextension_use_legacy[] =
10715 {"Not Allowed", "Allowed"};
10716
10717 #define LOOKUP(id, name) \
10718 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
10719 static arm_attr_public_tag arm_attr_public_tags[] =
10720 {
10721 {4, "CPU_raw_name", 1, NULL},
10722 {5, "CPU_name", 1, NULL},
10723 LOOKUP(6, CPU_arch),
10724 {7, "CPU_arch_profile", 0, NULL},
10725 LOOKUP(8, ARM_ISA_use),
10726 LOOKUP(9, THUMB_ISA_use),
10727 LOOKUP(10, FP_arch),
10728 LOOKUP(11, WMMX_arch),
10729 LOOKUP(12, Advanced_SIMD_arch),
10730 LOOKUP(13, PCS_config),
10731 LOOKUP(14, ABI_PCS_R9_use),
10732 LOOKUP(15, ABI_PCS_RW_data),
10733 LOOKUP(16, ABI_PCS_RO_data),
10734 LOOKUP(17, ABI_PCS_GOT_use),
10735 LOOKUP(18, ABI_PCS_wchar_t),
10736 LOOKUP(19, ABI_FP_rounding),
10737 LOOKUP(20, ABI_FP_denormal),
10738 LOOKUP(21, ABI_FP_exceptions),
10739 LOOKUP(22, ABI_FP_user_exceptions),
10740 LOOKUP(23, ABI_FP_number_model),
10741 {24, "ABI_align_needed", 0, NULL},
10742 {25, "ABI_align_preserved", 0, NULL},
10743 LOOKUP(26, ABI_enum_size),
10744 LOOKUP(27, ABI_HardFP_use),
10745 LOOKUP(28, ABI_VFP_args),
10746 LOOKUP(29, ABI_WMMX_args),
10747 LOOKUP(30, ABI_optimization_goals),
10748 LOOKUP(31, ABI_FP_optimization_goals),
10749 {32, "compatibility", 0, NULL},
10750 LOOKUP(34, CPU_unaligned_access),
10751 LOOKUP(36, FP_HP_extension),
10752 LOOKUP(38, ABI_FP_16bit_format),
10753 LOOKUP(42, MPextension_use),
10754 LOOKUP(44, DIV_use),
10755 {64, "nodefaults", 0, NULL},
10756 {65, "also_compatible_with", 0, NULL},
10757 LOOKUP(66, T2EE_use),
10758 {67, "conformance", 1, NULL},
10759 LOOKUP(68, Virtualization_use),
10760 LOOKUP(70, MPextension_use_legacy)
10761 };
10762 #undef LOOKUP
10763
10764 static unsigned char *
10765 display_arm_attribute (unsigned char * p)
10766 {
10767 int tag;
10768 unsigned int len;
10769 int val;
10770 arm_attr_public_tag * attr;
10771 unsigned i;
10772 int type;
10773
10774 tag = read_uleb128 (p, &len);
10775 p += len;
10776 attr = NULL;
10777 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
10778 {
10779 if (arm_attr_public_tags[i].tag == tag)
10780 {
10781 attr = &arm_attr_public_tags[i];
10782 break;
10783 }
10784 }
10785
10786 if (attr)
10787 {
10788 printf (" Tag_%s: ", attr->name);
10789 switch (attr->type)
10790 {
10791 case 0:
10792 switch (tag)
10793 {
10794 case 7: /* Tag_CPU_arch_profile. */
10795 val = read_uleb128 (p, &len);
10796 p += len;
10797 switch (val)
10798 {
10799 case 0: printf (_("None\n")); break;
10800 case 'A': printf (_("Application\n")); break;
10801 case 'R': printf (_("Realtime\n")); break;
10802 case 'M': printf (_("Microcontroller\n")); break;
10803 case 'S': printf (_("Application or Realtime\n")); break;
10804 default: printf ("??? (%d)\n", val); break;
10805 }
10806 break;
10807
10808 case 24: /* Tag_align_needed. */
10809 val = read_uleb128 (p, &len);
10810 p += len;
10811 switch (val)
10812 {
10813 case 0: printf (_("None\n")); break;
10814 case 1: printf (_("8-byte\n")); break;
10815 case 2: printf (_("4-byte\n")); break;
10816 case 3: printf ("??? 3\n"); break;
10817 default:
10818 if (val <= 12)
10819 printf (_("8-byte and up to %d-byte extended\n"),
10820 1 << val);
10821 else
10822 printf ("??? (%d)\n", val);
10823 break;
10824 }
10825 break;
10826
10827 case 25: /* Tag_align_preserved. */
10828 val = read_uleb128 (p, &len);
10829 p += len;
10830 switch (val)
10831 {
10832 case 0: printf (_("None\n")); break;
10833 case 1: printf (_("8-byte, except leaf SP\n")); break;
10834 case 2: printf (_("8-byte\n")); break;
10835 case 3: printf ("??? 3\n"); break;
10836 default:
10837 if (val <= 12)
10838 printf (_("8-byte and up to %d-byte extended\n"),
10839 1 << val);
10840 else
10841 printf ("??? (%d)\n", val);
10842 break;
10843 }
10844 break;
10845
10846 case 32: /* Tag_compatibility. */
10847 val = read_uleb128 (p, &len);
10848 p += len;
10849 printf (_("flag = %d, vendor = %s\n"), val, p);
10850 p += strlen ((char *) p) + 1;
10851 break;
10852
10853 case 64: /* Tag_nodefaults. */
10854 p++;
10855 printf (_("True\n"));
10856 break;
10857
10858 case 65: /* Tag_also_compatible_with. */
10859 val = read_uleb128 (p, &len);
10860 p += len;
10861 if (val == 6 /* Tag_CPU_arch. */)
10862 {
10863 val = read_uleb128 (p, &len);
10864 p += len;
10865 if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
10866 printf ("??? (%d)\n", val);
10867 else
10868 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
10869 }
10870 else
10871 printf ("???\n");
10872 while (*(p++) != '\0' /* NUL terminator. */);
10873 break;
10874
10875 default:
10876 abort ();
10877 }
10878 return p;
10879
10880 case 1:
10881 case 2:
10882 type = attr->type;
10883 break;
10884
10885 default:
10886 assert (attr->type & 0x80);
10887 val = read_uleb128 (p, &len);
10888 p += len;
10889 type = attr->type & 0x7f;
10890 if (val >= type)
10891 printf ("??? (%d)\n", val);
10892 else
10893 printf ("%s\n", attr->table[val]);
10894 return p;
10895 }
10896 }
10897 else
10898 {
10899 if (tag & 1)
10900 type = 1; /* String. */
10901 else
10902 type = 2; /* uleb128. */
10903 printf (" Tag_unknown_%d: ", tag);
10904 }
10905
10906 if (type == 1)
10907 {
10908 printf ("\"%s\"\n", p);
10909 p += strlen ((char *) p) + 1;
10910 }
10911 else
10912 {
10913 val = read_uleb128 (p, &len);
10914 p += len;
10915 printf ("%d (0x%x)\n", val, val);
10916 }
10917
10918 return p;
10919 }
10920
10921 static unsigned char *
10922 display_gnu_attribute (unsigned char * p,
10923 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
10924 {
10925 int tag;
10926 unsigned int len;
10927 int val;
10928 int type;
10929
10930 tag = read_uleb128 (p, &len);
10931 p += len;
10932
10933 /* Tag_compatibility is the only generic GNU attribute defined at
10934 present. */
10935 if (tag == 32)
10936 {
10937 val = read_uleb128 (p, &len);
10938 p += len;
10939 printf (_("flag = %d, vendor = %s\n"), val, p);
10940 p += strlen ((char *) p) + 1;
10941 return p;
10942 }
10943
10944 if ((tag & 2) == 0 && display_proc_gnu_attribute)
10945 return display_proc_gnu_attribute (p, tag);
10946
10947 if (tag & 1)
10948 type = 1; /* String. */
10949 else
10950 type = 2; /* uleb128. */
10951 printf (" Tag_unknown_%d: ", tag);
10952
10953 if (type == 1)
10954 {
10955 printf ("\"%s\"\n", p);
10956 p += strlen ((char *) p) + 1;
10957 }
10958 else
10959 {
10960 val = read_uleb128 (p, &len);
10961 p += len;
10962 printf ("%d (0x%x)\n", val, val);
10963 }
10964
10965 return p;
10966 }
10967
10968 static unsigned char *
10969 display_power_gnu_attribute (unsigned char * p, int tag)
10970 {
10971 int type;
10972 unsigned int len;
10973 int val;
10974
10975 if (tag == Tag_GNU_Power_ABI_FP)
10976 {
10977 val = read_uleb128 (p, &len);
10978 p += len;
10979 printf (" Tag_GNU_Power_ABI_FP: ");
10980
10981 switch (val)
10982 {
10983 case 0:
10984 printf (_("Hard or soft float\n"));
10985 break;
10986 case 1:
10987 printf (_("Hard float\n"));
10988 break;
10989 case 2:
10990 printf (_("Soft float\n"));
10991 break;
10992 case 3:
10993 printf (_("Single-precision hard float\n"));
10994 break;
10995 default:
10996 printf ("??? (%d)\n", val);
10997 break;
10998 }
10999 return p;
11000 }
11001
11002 if (tag == Tag_GNU_Power_ABI_Vector)
11003 {
11004 val = read_uleb128 (p, &len);
11005 p += len;
11006 printf (" Tag_GNU_Power_ABI_Vector: ");
11007 switch (val)
11008 {
11009 case 0:
11010 printf (_("Any\n"));
11011 break;
11012 case 1:
11013 printf (_("Generic\n"));
11014 break;
11015 case 2:
11016 printf ("AltiVec\n");
11017 break;
11018 case 3:
11019 printf ("SPE\n");
11020 break;
11021 default:
11022 printf ("??? (%d)\n", val);
11023 break;
11024 }
11025 return p;
11026 }
11027
11028 if (tag == Tag_GNU_Power_ABI_Struct_Return)
11029 {
11030 val = read_uleb128 (p, &len);
11031 p += len;
11032 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
11033 switch (val)
11034 {
11035 case 0:
11036 printf (_("Any\n"));
11037 break;
11038 case 1:
11039 printf ("r3/r4\n");
11040 break;
11041 case 2:
11042 printf (_("Memory\n"));
11043 break;
11044 default:
11045 printf ("??? (%d)\n", val);
11046 break;
11047 }
11048 return p;
11049 }
11050
11051 if (tag & 1)
11052 type = 1; /* String. */
11053 else
11054 type = 2; /* uleb128. */
11055 printf (" Tag_unknown_%d: ", tag);
11056
11057 if (type == 1)
11058 {
11059 printf ("\"%s\"\n", p);
11060 p += strlen ((char *) p) + 1;
11061 }
11062 else
11063 {
11064 val = read_uleb128 (p, &len);
11065 p += len;
11066 printf ("%d (0x%x)\n", val, val);
11067 }
11068
11069 return p;
11070 }
11071
11072 static unsigned char *
11073 display_mips_gnu_attribute (unsigned char * p, int tag)
11074 {
11075 int type;
11076 unsigned int len;
11077 int val;
11078
11079 if (tag == Tag_GNU_MIPS_ABI_FP)
11080 {
11081 val = read_uleb128 (p, &len);
11082 p += len;
11083 printf (" Tag_GNU_MIPS_ABI_FP: ");
11084
11085 switch (val)
11086 {
11087 case 0:
11088 printf (_("Hard or soft float\n"));
11089 break;
11090 case 1:
11091 printf (_("Hard float (double precision)\n"));
11092 break;
11093 case 2:
11094 printf (_("Hard float (single precision)\n"));
11095 break;
11096 case 3:
11097 printf (_("Soft float\n"));
11098 break;
11099 case 4:
11100 printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
11101 break;
11102 default:
11103 printf ("??? (%d)\n", val);
11104 break;
11105 }
11106 return p;
11107 }
11108
11109 if (tag & 1)
11110 type = 1; /* String. */
11111 else
11112 type = 2; /* uleb128. */
11113 printf (" Tag_unknown_%d: ", tag);
11114
11115 if (type == 1)
11116 {
11117 printf ("\"%s\"\n", p);
11118 p += strlen ((char *) p) + 1;
11119 }
11120 else
11121 {
11122 val = read_uleb128 (p, &len);
11123 p += len;
11124 printf ("%d (0x%x)\n", val, val);
11125 }
11126
11127 return p;
11128 }
11129
11130 static unsigned char *
11131 display_tic6x_attribute (unsigned char * p)
11132 {
11133 int tag;
11134 unsigned int len;
11135 int val;
11136
11137 tag = read_uleb128 (p, &len);
11138 p += len;
11139
11140 switch (tag)
11141 {
11142 case Tag_ISA:
11143 val = read_uleb128 (p, &len);
11144 p += len;
11145 printf (" Tag_ISA: ");
11146
11147 switch (val)
11148 {
11149 case C6XABI_Tag_ISA_none:
11150 printf (_("None\n"));
11151 break;
11152 case C6XABI_Tag_ISA_C62X:
11153 printf ("C62x\n");
11154 break;
11155 case C6XABI_Tag_ISA_C67X:
11156 printf ("C67x\n");
11157 break;
11158 case C6XABI_Tag_ISA_C67XP:
11159 printf ("C67x+\n");
11160 break;
11161 case C6XABI_Tag_ISA_C64X:
11162 printf ("C64x\n");
11163 break;
11164 case C6XABI_Tag_ISA_C64XP:
11165 printf ("C64x+\n");
11166 break;
11167 case C6XABI_Tag_ISA_C674X:
11168 printf ("C674x\n");
11169 break;
11170 default:
11171 printf ("??? (%d)\n", val);
11172 break;
11173 }
11174 return p;
11175
11176 case Tag_ABI_wchar_t:
11177 val = read_uleb128 (p, &len);
11178 p += len;
11179 printf (" Tag_ABI_wchar_t: ");
11180 switch (val)
11181 {
11182 case 0:
11183 printf (_("Not used\n"));
11184 break;
11185 case 1:
11186 printf (_("2 bytes\n"));
11187 break;
11188 case 2:
11189 printf (_("4 bytes\n"));
11190 break;
11191 default:
11192 printf ("??? (%d)\n", val);
11193 break;
11194 }
11195 return p;
11196
11197 case Tag_ABI_stack_align_needed:
11198 val = read_uleb128 (p, &len);
11199 p += len;
11200 printf (" Tag_ABI_stack_align_needed: ");
11201 switch (val)
11202 {
11203 case 0:
11204 printf (_("8-byte\n"));
11205 break;
11206 case 1:
11207 printf (_("16-byte\n"));
11208 break;
11209 default:
11210 printf ("??? (%d)\n", val);
11211 break;
11212 }
11213 return p;
11214
11215 case Tag_ABI_stack_align_preserved:
11216 val = read_uleb128 (p, &len);
11217 p += len;
11218 printf (" Tag_ABI_stack_align_preserved: ");
11219 switch (val)
11220 {
11221 case 0:
11222 printf (_("8-byte\n"));
11223 break;
11224 case 1:
11225 printf (_("16-byte\n"));
11226 break;
11227 default:
11228 printf ("??? (%d)\n", val);
11229 break;
11230 }
11231 return p;
11232
11233 case Tag_ABI_DSBT:
11234 val = read_uleb128 (p, &len);
11235 p += len;
11236 printf (" Tag_ABI_DSBT: ");
11237 switch (val)
11238 {
11239 case 0:
11240 printf (_("DSBT addressing not used\n"));
11241 break;
11242 case 1:
11243 printf (_("DSBT addressing used\n"));
11244 break;
11245 default:
11246 printf ("??? (%d)\n", val);
11247 break;
11248 }
11249 return p;
11250
11251 case Tag_ABI_PID:
11252 val = read_uleb128 (p, &len);
11253 p += len;
11254 printf (" Tag_ABI_PID: ");
11255 switch (val)
11256 {
11257 case 0:
11258 printf (_("Data addressing position-dependent\n"));
11259 break;
11260 case 1:
11261 printf (_("Data addressing position-independent, GOT near DP\n"));
11262 break;
11263 case 2:
11264 printf (_("Data addressing position-independent, GOT far from DP\n"));
11265 break;
11266 default:
11267 printf ("??? (%d)\n", val);
11268 break;
11269 }
11270 return p;
11271
11272 case Tag_ABI_PIC:
11273 val = read_uleb128 (p, &len);
11274 p += len;
11275 printf (" Tag_ABI_PIC: ");
11276 switch (val)
11277 {
11278 case 0:
11279 printf (_("Code addressing position-dependent\n"));
11280 break;
11281 case 1:
11282 printf (_("Code addressing position-independent\n"));
11283 break;
11284 default:
11285 printf ("??? (%d)\n", val);
11286 break;
11287 }
11288 return p;
11289
11290 case Tag_ABI_array_object_alignment:
11291 val = read_uleb128 (p, &len);
11292 p += len;
11293 printf (" Tag_ABI_array_object_alignment: ");
11294 switch (val)
11295 {
11296 case 0:
11297 printf (_("8-byte\n"));
11298 break;
11299 case 1:
11300 printf (_("4-byte\n"));
11301 break;
11302 case 2:
11303 printf (_("16-byte\n"));
11304 break;
11305 default:
11306 printf ("??? (%d)\n", val);
11307 break;
11308 }
11309 return p;
11310
11311 case Tag_ABI_array_object_align_expected:
11312 val = read_uleb128 (p, &len);
11313 p += len;
11314 printf (" Tag_ABI_array_object_align_expected: ");
11315 switch (val)
11316 {
11317 case 0:
11318 printf (_("8-byte\n"));
11319 break;
11320 case 1:
11321 printf (_("4-byte\n"));
11322 break;
11323 case 2:
11324 printf (_("16-byte\n"));
11325 break;
11326 default:
11327 printf ("??? (%d)\n", val);
11328 break;
11329 }
11330 return p;
11331
11332 case Tag_ABI_compatibility:
11333 val = read_uleb128 (p, &len);
11334 p += len;
11335 printf (" Tag_ABI_compatibility: ");
11336 printf (_("flag = %d, vendor = %s\n"), val, p);
11337 p += strlen ((char *) p) + 1;
11338 return p;
11339
11340 case Tag_ABI_conformance:
11341 printf (" Tag_ABI_conformance: ");
11342 printf ("\"%s\"\n", p);
11343 p += strlen ((char *) p) + 1;
11344 return p;
11345 }
11346
11347 printf (" Tag_unknown_%d: ", tag);
11348
11349 if (tag & 1)
11350 {
11351 printf ("\"%s\"\n", p);
11352 p += strlen ((char *) p) + 1;
11353 }
11354 else
11355 {
11356 val = read_uleb128 (p, &len);
11357 p += len;
11358 printf ("%d (0x%x)\n", val, val);
11359 }
11360
11361 return p;
11362 }
11363
11364 static int
11365 process_attributes (FILE * file,
11366 const char * public_name,
11367 unsigned int proc_type,
11368 unsigned char * (* display_pub_attribute) (unsigned char *),
11369 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
11370 {
11371 Elf_Internal_Shdr * sect;
11372 unsigned char * contents;
11373 unsigned char * p;
11374 unsigned char * end;
11375 bfd_vma section_len;
11376 bfd_vma len;
11377 unsigned i;
11378
11379 /* Find the section header so that we get the size. */
11380 for (i = 0, sect = section_headers;
11381 i < elf_header.e_shnum;
11382 i++, sect++)
11383 {
11384 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11385 continue;
11386
11387 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
11388 sect->sh_size, _("attributes"));
11389 if (contents == NULL)
11390 continue;
11391
11392 p = contents;
11393 if (*p == 'A')
11394 {
11395 len = sect->sh_size - 1;
11396 p++;
11397
11398 while (len > 0)
11399 {
11400 int namelen;
11401 bfd_boolean public_section;
11402 bfd_boolean gnu_section;
11403
11404 section_len = byte_get (p, 4);
11405 p += 4;
11406
11407 if (section_len > len)
11408 {
11409 printf (_("ERROR: Bad section length (%d > %d)\n"),
11410 (int) section_len, (int) len);
11411 section_len = len;
11412 }
11413
11414 len -= section_len;
11415 printf (_("Attribute Section: %s\n"), p);
11416
11417 if (public_name && streq ((char *) p, public_name))
11418 public_section = TRUE;
11419 else
11420 public_section = FALSE;
11421
11422 if (streq ((char *) p, "gnu"))
11423 gnu_section = TRUE;
11424 else
11425 gnu_section = FALSE;
11426
11427 namelen = strlen ((char *) p) + 1;
11428 p += namelen;
11429 section_len -= namelen + 4;
11430
11431 while (section_len > 0)
11432 {
11433 int tag = *(p++);
11434 int val;
11435 bfd_vma size;
11436
11437 size = byte_get (p, 4);
11438 if (size > section_len)
11439 {
11440 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
11441 (int) size, (int) section_len);
11442 size = section_len;
11443 }
11444
11445 section_len -= size;
11446 end = p + size - 1;
11447 p += 4;
11448
11449 switch (tag)
11450 {
11451 case 1:
11452 printf (_("File Attributes\n"));
11453 break;
11454 case 2:
11455 printf (_("Section Attributes:"));
11456 goto do_numlist;
11457 case 3:
11458 printf (_("Symbol Attributes:"));
11459 do_numlist:
11460 for (;;)
11461 {
11462 unsigned int j;
11463
11464 val = read_uleb128 (p, &j);
11465 p += j;
11466 if (val == 0)
11467 break;
11468 printf (" %d", val);
11469 }
11470 printf ("\n");
11471 break;
11472 default:
11473 printf (_("Unknown tag: %d\n"), tag);
11474 public_section = FALSE;
11475 break;
11476 }
11477
11478 if (public_section)
11479 {
11480 while (p < end)
11481 p = display_pub_attribute (p);
11482 }
11483 else if (gnu_section)
11484 {
11485 while (p < end)
11486 p = display_gnu_attribute (p,
11487 display_proc_gnu_attribute);
11488 }
11489 else
11490 {
11491 /* ??? Do something sensible, like dump hex. */
11492 printf (_(" Unknown section contexts\n"));
11493 p = end;
11494 }
11495 }
11496 }
11497 }
11498 else
11499 printf (_("Unknown format '%c'\n"), *p);
11500
11501 free (contents);
11502 }
11503 return 1;
11504 }
11505
11506 static int
11507 process_arm_specific (FILE * file)
11508 {
11509 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
11510 display_arm_attribute, NULL);
11511 }
11512
11513 static int
11514 process_power_specific (FILE * file)
11515 {
11516 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11517 display_power_gnu_attribute);
11518 }
11519
11520 static int
11521 process_tic6x_specific (FILE * file)
11522 {
11523 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
11524 display_tic6x_attribute, NULL);
11525 }
11526
11527 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
11528 Print the Address, Access and Initial fields of an entry at VMA ADDR
11529 and return the VMA of the next entry. */
11530
11531 static bfd_vma
11532 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
11533 {
11534 printf (" ");
11535 print_vma (addr, LONG_HEX);
11536 printf (" ");
11537 if (addr < pltgot + 0xfff0)
11538 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
11539 else
11540 printf ("%10s", "");
11541 printf (" ");
11542 if (data == NULL)
11543 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
11544 else
11545 {
11546 bfd_vma entry;
11547
11548 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
11549 print_vma (entry, LONG_HEX);
11550 }
11551 return addr + (is_32bit_elf ? 4 : 8);
11552 }
11553
11554 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
11555 PLTGOT. Print the Address and Initial fields of an entry at VMA
11556 ADDR and return the VMA of the next entry. */
11557
11558 static bfd_vma
11559 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
11560 {
11561 printf (" ");
11562 print_vma (addr, LONG_HEX);
11563 printf (" ");
11564 if (data == NULL)
11565 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
11566 else
11567 {
11568 bfd_vma entry;
11569
11570 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
11571 print_vma (entry, LONG_HEX);
11572 }
11573 return addr + (is_32bit_elf ? 4 : 8);
11574 }
11575
11576 static int
11577 process_mips_specific (FILE * file)
11578 {
11579 Elf_Internal_Dyn * entry;
11580 size_t liblist_offset = 0;
11581 size_t liblistno = 0;
11582 size_t conflictsno = 0;
11583 size_t options_offset = 0;
11584 size_t conflicts_offset = 0;
11585 size_t pltrelsz = 0;
11586 size_t pltrel = 0;
11587 bfd_vma pltgot = 0;
11588 bfd_vma mips_pltgot = 0;
11589 bfd_vma jmprel = 0;
11590 bfd_vma local_gotno = 0;
11591 bfd_vma gotsym = 0;
11592 bfd_vma symtabno = 0;
11593
11594 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11595 display_mips_gnu_attribute);
11596
11597 /* We have a lot of special sections. Thanks SGI! */
11598 if (dynamic_section == NULL)
11599 /* No information available. */
11600 return 0;
11601
11602 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
11603 switch (entry->d_tag)
11604 {
11605 case DT_MIPS_LIBLIST:
11606 liblist_offset
11607 = offset_from_vma (file, entry->d_un.d_val,
11608 liblistno * sizeof (Elf32_External_Lib));
11609 break;
11610 case DT_MIPS_LIBLISTNO:
11611 liblistno = entry->d_un.d_val;
11612 break;
11613 case DT_MIPS_OPTIONS:
11614 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
11615 break;
11616 case DT_MIPS_CONFLICT:
11617 conflicts_offset
11618 = offset_from_vma (file, entry->d_un.d_val,
11619 conflictsno * sizeof (Elf32_External_Conflict));
11620 break;
11621 case DT_MIPS_CONFLICTNO:
11622 conflictsno = entry->d_un.d_val;
11623 break;
11624 case DT_PLTGOT:
11625 pltgot = entry->d_un.d_ptr;
11626 break;
11627 case DT_MIPS_LOCAL_GOTNO:
11628 local_gotno = entry->d_un.d_val;
11629 break;
11630 case DT_MIPS_GOTSYM:
11631 gotsym = entry->d_un.d_val;
11632 break;
11633 case DT_MIPS_SYMTABNO:
11634 symtabno = entry->d_un.d_val;
11635 break;
11636 case DT_MIPS_PLTGOT:
11637 mips_pltgot = entry->d_un.d_ptr;
11638 break;
11639 case DT_PLTREL:
11640 pltrel = entry->d_un.d_val;
11641 break;
11642 case DT_PLTRELSZ:
11643 pltrelsz = entry->d_un.d_val;
11644 break;
11645 case DT_JMPREL:
11646 jmprel = entry->d_un.d_ptr;
11647 break;
11648 default:
11649 break;
11650 }
11651
11652 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
11653 {
11654 Elf32_External_Lib * elib;
11655 size_t cnt;
11656
11657 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
11658 liblistno,
11659 sizeof (Elf32_External_Lib),
11660 _("liblist"));
11661 if (elib)
11662 {
11663 printf (_("\nSection '.liblist' contains %lu entries:\n"),
11664 (unsigned long) liblistno);
11665 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
11666 stdout);
11667
11668 for (cnt = 0; cnt < liblistno; ++cnt)
11669 {
11670 Elf32_Lib liblist;
11671 time_t atime;
11672 char timebuf[20];
11673 struct tm * tmp;
11674
11675 liblist.l_name = BYTE_GET (elib[cnt].l_name);
11676 atime = BYTE_GET (elib[cnt].l_time_stamp);
11677 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
11678 liblist.l_version = BYTE_GET (elib[cnt].l_version);
11679 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
11680
11681 tmp = gmtime (&atime);
11682 snprintf (timebuf, sizeof (timebuf),
11683 "%04u-%02u-%02uT%02u:%02u:%02u",
11684 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
11685 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
11686
11687 printf ("%3lu: ", (unsigned long) cnt);
11688 if (VALID_DYNAMIC_NAME (liblist.l_name))
11689 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
11690 else
11691 printf (_("<corrupt: %9ld>"), liblist.l_name);
11692 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
11693 liblist.l_version);
11694
11695 if (liblist.l_flags == 0)
11696 puts (_(" NONE"));
11697 else
11698 {
11699 static const struct
11700 {
11701 const char * name;
11702 int bit;
11703 }
11704 l_flags_vals[] =
11705 {
11706 { " EXACT_MATCH", LL_EXACT_MATCH },
11707 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
11708 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
11709 { " EXPORTS", LL_EXPORTS },
11710 { " DELAY_LOAD", LL_DELAY_LOAD },
11711 { " DELTA", LL_DELTA }
11712 };
11713 int flags = liblist.l_flags;
11714 size_t fcnt;
11715
11716 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
11717 if ((flags & l_flags_vals[fcnt].bit) != 0)
11718 {
11719 fputs (l_flags_vals[fcnt].name, stdout);
11720 flags ^= l_flags_vals[fcnt].bit;
11721 }
11722 if (flags != 0)
11723 printf (" %#x", (unsigned int) flags);
11724
11725 puts ("");
11726 }
11727 }
11728
11729 free (elib);
11730 }
11731 }
11732
11733 if (options_offset != 0)
11734 {
11735 Elf_External_Options * eopt;
11736 Elf_Internal_Shdr * sect = section_headers;
11737 Elf_Internal_Options * iopt;
11738 Elf_Internal_Options * option;
11739 size_t offset;
11740 int cnt;
11741
11742 /* Find the section header so that we get the size. */
11743 while (sect->sh_type != SHT_MIPS_OPTIONS)
11744 ++sect;
11745
11746 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
11747 sect->sh_size, _("options"));
11748 if (eopt)
11749 {
11750 iopt = (Elf_Internal_Options *)
11751 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
11752 if (iopt == NULL)
11753 {
11754 error (_("Out of memory\n"));
11755 return 0;
11756 }
11757
11758 offset = cnt = 0;
11759 option = iopt;
11760
11761 while (offset < sect->sh_size)
11762 {
11763 Elf_External_Options * eoption;
11764
11765 eoption = (Elf_External_Options *) ((char *) eopt + offset);
11766
11767 option->kind = BYTE_GET (eoption->kind);
11768 option->size = BYTE_GET (eoption->size);
11769 option->section = BYTE_GET (eoption->section);
11770 option->info = BYTE_GET (eoption->info);
11771
11772 offset += option->size;
11773
11774 ++option;
11775 ++cnt;
11776 }
11777
11778 printf (_("\nSection '%s' contains %d entries:\n"),
11779 SECTION_NAME (sect), cnt);
11780
11781 option = iopt;
11782
11783 while (cnt-- > 0)
11784 {
11785 size_t len;
11786
11787 switch (option->kind)
11788 {
11789 case ODK_NULL:
11790 /* This shouldn't happen. */
11791 printf (" NULL %d %lx", option->section, option->info);
11792 break;
11793 case ODK_REGINFO:
11794 printf (" REGINFO ");
11795 if (elf_header.e_machine == EM_MIPS)
11796 {
11797 /* 32bit form. */
11798 Elf32_External_RegInfo * ereg;
11799 Elf32_RegInfo reginfo;
11800
11801 ereg = (Elf32_External_RegInfo *) (option + 1);
11802 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
11803 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
11804 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
11805 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
11806 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
11807 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
11808
11809 printf ("GPR %08lx GP 0x%lx\n",
11810 reginfo.ri_gprmask,
11811 (unsigned long) reginfo.ri_gp_value);
11812 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11813 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
11814 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
11815 }
11816 else
11817 {
11818 /* 64 bit form. */
11819 Elf64_External_RegInfo * ereg;
11820 Elf64_Internal_RegInfo reginfo;
11821
11822 ereg = (Elf64_External_RegInfo *) (option + 1);
11823 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
11824 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
11825 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
11826 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
11827 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
11828 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
11829
11830 printf ("GPR %08lx GP 0x",
11831 reginfo.ri_gprmask);
11832 printf_vma (reginfo.ri_gp_value);
11833 printf ("\n");
11834
11835 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11836 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
11837 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
11838 }
11839 ++option;
11840 continue;
11841 case ODK_EXCEPTIONS:
11842 fputs (" EXCEPTIONS fpe_min(", stdout);
11843 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
11844 fputs (") fpe_max(", stdout);
11845 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
11846 fputs (")", stdout);
11847
11848 if (option->info & OEX_PAGE0)
11849 fputs (" PAGE0", stdout);
11850 if (option->info & OEX_SMM)
11851 fputs (" SMM", stdout);
11852 if (option->info & OEX_FPDBUG)
11853 fputs (" FPDBUG", stdout);
11854 if (option->info & OEX_DISMISS)
11855 fputs (" DISMISS", stdout);
11856 break;
11857 case ODK_PAD:
11858 fputs (" PAD ", stdout);
11859 if (option->info & OPAD_PREFIX)
11860 fputs (" PREFIX", stdout);
11861 if (option->info & OPAD_POSTFIX)
11862 fputs (" POSTFIX", stdout);
11863 if (option->info & OPAD_SYMBOL)
11864 fputs (" SYMBOL", stdout);
11865 break;
11866 case ODK_HWPATCH:
11867 fputs (" HWPATCH ", stdout);
11868 if (option->info & OHW_R4KEOP)
11869 fputs (" R4KEOP", stdout);
11870 if (option->info & OHW_R8KPFETCH)
11871 fputs (" R8KPFETCH", stdout);
11872 if (option->info & OHW_R5KEOP)
11873 fputs (" R5KEOP", stdout);
11874 if (option->info & OHW_R5KCVTL)
11875 fputs (" R5KCVTL", stdout);
11876 break;
11877 case ODK_FILL:
11878 fputs (" FILL ", stdout);
11879 /* XXX Print content of info word? */
11880 break;
11881 case ODK_TAGS:
11882 fputs (" TAGS ", stdout);
11883 /* XXX Print content of info word? */
11884 break;
11885 case ODK_HWAND:
11886 fputs (" HWAND ", stdout);
11887 if (option->info & OHWA0_R4KEOP_CHECKED)
11888 fputs (" R4KEOP_CHECKED", stdout);
11889 if (option->info & OHWA0_R4KEOP_CLEAN)
11890 fputs (" R4KEOP_CLEAN", stdout);
11891 break;
11892 case ODK_HWOR:
11893 fputs (" HWOR ", stdout);
11894 if (option->info & OHWA0_R4KEOP_CHECKED)
11895 fputs (" R4KEOP_CHECKED", stdout);
11896 if (option->info & OHWA0_R4KEOP_CLEAN)
11897 fputs (" R4KEOP_CLEAN", stdout);
11898 break;
11899 case ODK_GP_GROUP:
11900 printf (" GP_GROUP %#06lx self-contained %#06lx",
11901 option->info & OGP_GROUP,
11902 (option->info & OGP_SELF) >> 16);
11903 break;
11904 case ODK_IDENT:
11905 printf (" IDENT %#06lx self-contained %#06lx",
11906 option->info & OGP_GROUP,
11907 (option->info & OGP_SELF) >> 16);
11908 break;
11909 default:
11910 /* This shouldn't happen. */
11911 printf (" %3d ??? %d %lx",
11912 option->kind, option->section, option->info);
11913 break;
11914 }
11915
11916 len = sizeof (* eopt);
11917 while (len < option->size)
11918 if (((char *) option)[len] >= ' '
11919 && ((char *) option)[len] < 0x7f)
11920 printf ("%c", ((char *) option)[len++]);
11921 else
11922 printf ("\\%03o", ((char *) option)[len++]);
11923
11924 fputs ("\n", stdout);
11925 ++option;
11926 }
11927
11928 free (eopt);
11929 }
11930 }
11931
11932 if (conflicts_offset != 0 && conflictsno != 0)
11933 {
11934 Elf32_Conflict * iconf;
11935 size_t cnt;
11936
11937 if (dynamic_symbols == NULL)
11938 {
11939 error (_("conflict list found without a dynamic symbol table\n"));
11940 return 0;
11941 }
11942
11943 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
11944 if (iconf == NULL)
11945 {
11946 error (_("Out of memory\n"));
11947 return 0;
11948 }
11949
11950 if (is_32bit_elf)
11951 {
11952 Elf32_External_Conflict * econf32;
11953
11954 econf32 = (Elf32_External_Conflict *)
11955 get_data (NULL, file, conflicts_offset, conflictsno,
11956 sizeof (* econf32), _("conflict"));
11957 if (!econf32)
11958 return 0;
11959
11960 for (cnt = 0; cnt < conflictsno; ++cnt)
11961 iconf[cnt] = BYTE_GET (econf32[cnt]);
11962
11963 free (econf32);
11964 }
11965 else
11966 {
11967 Elf64_External_Conflict * econf64;
11968
11969 econf64 = (Elf64_External_Conflict *)
11970 get_data (NULL, file, conflicts_offset, conflictsno,
11971 sizeof (* econf64), _("conflict"));
11972 if (!econf64)
11973 return 0;
11974
11975 for (cnt = 0; cnt < conflictsno; ++cnt)
11976 iconf[cnt] = BYTE_GET (econf64[cnt]);
11977
11978 free (econf64);
11979 }
11980
11981 printf (_("\nSection '.conflict' contains %lu entries:\n"),
11982 (unsigned long) conflictsno);
11983 puts (_(" Num: Index Value Name"));
11984
11985 for (cnt = 0; cnt < conflictsno; ++cnt)
11986 {
11987 Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
11988
11989 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
11990 print_vma (psym->st_value, FULL_HEX);
11991 putchar (' ');
11992 if (VALID_DYNAMIC_NAME (psym->st_name))
11993 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11994 else
11995 printf (_("<corrupt: %14ld>"), psym->st_name);
11996 putchar ('\n');
11997 }
11998
11999 free (iconf);
12000 }
12001
12002 if (pltgot != 0 && local_gotno != 0)
12003 {
12004 bfd_vma ent, local_end, global_end;
12005 size_t i, offset;
12006 unsigned char * data;
12007 int addr_size;
12008
12009 ent = pltgot;
12010 addr_size = (is_32bit_elf ? 4 : 8);
12011 local_end = pltgot + local_gotno * addr_size;
12012 global_end = local_end + (symtabno - gotsym) * addr_size;
12013
12014 offset = offset_from_vma (file, pltgot, global_end - pltgot);
12015 data = (unsigned char *) get_data (NULL, file, offset,
12016 global_end - pltgot, 1, _("GOT"));
12017 if (data == NULL)
12018 return 0;
12019
12020 printf (_("\nPrimary GOT:\n"));
12021 printf (_(" Canonical gp value: "));
12022 print_vma (pltgot + 0x7ff0, LONG_HEX);
12023 printf ("\n\n");
12024
12025 printf (_(" Reserved entries:\n"));
12026 printf (_(" %*s %10s %*s Purpose\n"),
12027 addr_size * 2, _("Address"), _("Access"),
12028 addr_size * 2, _("Initial"));
12029 ent = print_mips_got_entry (data, pltgot, ent);
12030 printf (_(" Lazy resolver\n"));
12031 if (data
12032 && (byte_get (data + ent - pltgot, addr_size)
12033 >> (addr_size * 8 - 1)) != 0)
12034 {
12035 ent = print_mips_got_entry (data, pltgot, ent);
12036 printf (_(" Module pointer (GNU extension)\n"));
12037 }
12038 printf ("\n");
12039
12040 if (ent < local_end)
12041 {
12042 printf (_(" Local entries:\n"));
12043 printf (" %*s %10s %*s\n",
12044 addr_size * 2, _("Address"), _("Access"),
12045 addr_size * 2, _("Initial"));
12046 while (ent < local_end)
12047 {
12048 ent = print_mips_got_entry (data, pltgot, ent);
12049 printf ("\n");
12050 }
12051 printf ("\n");
12052 }
12053
12054 if (gotsym < symtabno)
12055 {
12056 int sym_width;
12057
12058 printf (_(" Global entries:\n"));
12059 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
12060 addr_size * 2, _("Address"), _("Access"),
12061 addr_size * 2, _("Initial"),
12062 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
12063 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
12064 for (i = gotsym; i < symtabno; i++)
12065 {
12066 Elf_Internal_Sym * psym;
12067
12068 psym = dynamic_symbols + i;
12069 ent = print_mips_got_entry (data, pltgot, ent);
12070 printf (" ");
12071 print_vma (psym->st_value, LONG_HEX);
12072 printf (" %-7s %3s ",
12073 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12074 get_symbol_index_type (psym->st_shndx));
12075 if (VALID_DYNAMIC_NAME (psym->st_name))
12076 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12077 else
12078 printf (_("<corrupt: %14ld>"), psym->st_name);
12079 printf ("\n");
12080 }
12081 printf ("\n");
12082 }
12083
12084 if (data)
12085 free (data);
12086 }
12087
12088 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
12089 {
12090 bfd_vma ent, end;
12091 size_t offset, rel_offset;
12092 unsigned long count, i;
12093 unsigned char * data;
12094 int addr_size, sym_width;
12095 Elf_Internal_Rela * rels;
12096
12097 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
12098 if (pltrel == DT_RELA)
12099 {
12100 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
12101 return 0;
12102 }
12103 else
12104 {
12105 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
12106 return 0;
12107 }
12108
12109 ent = mips_pltgot;
12110 addr_size = (is_32bit_elf ? 4 : 8);
12111 end = mips_pltgot + (2 + count) * addr_size;
12112
12113 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
12114 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
12115 1, _("PLT GOT"));
12116 if (data == NULL)
12117 return 0;
12118
12119 printf (_("\nPLT GOT:\n\n"));
12120 printf (_(" Reserved entries:\n"));
12121 printf (_(" %*s %*s Purpose\n"),
12122 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
12123 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12124 printf (_(" PLT lazy resolver\n"));
12125 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12126 printf (_(" Module pointer\n"));
12127 printf ("\n");
12128
12129 printf (_(" Entries:\n"));
12130 printf (" %*s %*s %*s %-7s %3s %s\n",
12131 addr_size * 2, _("Address"),
12132 addr_size * 2, _("Initial"),
12133 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
12134 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
12135 for (i = 0; i < count; i++)
12136 {
12137 Elf_Internal_Sym * psym;
12138
12139 psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
12140 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12141 printf (" ");
12142 print_vma (psym->st_value, LONG_HEX);
12143 printf (" %-7s %3s ",
12144 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12145 get_symbol_index_type (psym->st_shndx));
12146 if (VALID_DYNAMIC_NAME (psym->st_name))
12147 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12148 else
12149 printf (_("<corrupt: %14ld>"), psym->st_name);
12150 printf ("\n");
12151 }
12152 printf ("\n");
12153
12154 if (data)
12155 free (data);
12156 free (rels);
12157 }
12158
12159 return 1;
12160 }
12161
12162 static int
12163 process_gnu_liblist (FILE * file)
12164 {
12165 Elf_Internal_Shdr * section;
12166 Elf_Internal_Shdr * string_sec;
12167 Elf32_External_Lib * elib;
12168 char * strtab;
12169 size_t strtab_size;
12170 size_t cnt;
12171 unsigned i;
12172
12173 if (! do_arch)
12174 return 0;
12175
12176 for (i = 0, section = section_headers;
12177 i < elf_header.e_shnum;
12178 i++, section++)
12179 {
12180 switch (section->sh_type)
12181 {
12182 case SHT_GNU_LIBLIST:
12183 if (section->sh_link >= elf_header.e_shnum)
12184 break;
12185
12186 elib = (Elf32_External_Lib *)
12187 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
12188 _("liblist"));
12189
12190 if (elib == NULL)
12191 break;
12192 string_sec = section_headers + section->sh_link;
12193
12194 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
12195 string_sec->sh_size,
12196 _("liblist string table"));
12197 if (strtab == NULL
12198 || section->sh_entsize != sizeof (Elf32_External_Lib))
12199 {
12200 free (elib);
12201 free (strtab);
12202 break;
12203 }
12204 strtab_size = string_sec->sh_size;
12205
12206 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
12207 SECTION_NAME (section),
12208 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
12209
12210 puts (_(" Library Time Stamp Checksum Version Flags"));
12211
12212 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
12213 ++cnt)
12214 {
12215 Elf32_Lib liblist;
12216 time_t atime;
12217 char timebuf[20];
12218 struct tm * tmp;
12219
12220 liblist.l_name = BYTE_GET (elib[cnt].l_name);
12221 atime = BYTE_GET (elib[cnt].l_time_stamp);
12222 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12223 liblist.l_version = BYTE_GET (elib[cnt].l_version);
12224 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12225
12226 tmp = gmtime (&atime);
12227 snprintf (timebuf, sizeof (timebuf),
12228 "%04u-%02u-%02uT%02u:%02u:%02u",
12229 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12230 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
12231
12232 printf ("%3lu: ", (unsigned long) cnt);
12233 if (do_wide)
12234 printf ("%-20s", liblist.l_name < strtab_size
12235 ? strtab + liblist.l_name : _("<corrupt>"));
12236 else
12237 printf ("%-20.20s", liblist.l_name < strtab_size
12238 ? strtab + liblist.l_name : _("<corrupt>"));
12239 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
12240 liblist.l_version, liblist.l_flags);
12241 }
12242
12243 free (elib);
12244 free (strtab);
12245 }
12246 }
12247
12248 return 1;
12249 }
12250
12251 static const char *
12252 get_note_type (unsigned e_type)
12253 {
12254 static char buff[64];
12255
12256 if (elf_header.e_type == ET_CORE)
12257 switch (e_type)
12258 {
12259 case NT_AUXV:
12260 return _("NT_AUXV (auxiliary vector)");
12261 case NT_PRSTATUS:
12262 return _("NT_PRSTATUS (prstatus structure)");
12263 case NT_FPREGSET:
12264 return _("NT_FPREGSET (floating point registers)");
12265 case NT_PRPSINFO:
12266 return _("NT_PRPSINFO (prpsinfo structure)");
12267 case NT_TASKSTRUCT:
12268 return _("NT_TASKSTRUCT (task structure)");
12269 case NT_PRXFPREG:
12270 return _("NT_PRXFPREG (user_xfpregs structure)");
12271 case NT_PPC_VMX:
12272 return _("NT_PPC_VMX (ppc Altivec registers)");
12273 case NT_PPC_VSX:
12274 return _("NT_PPC_VSX (ppc VSX registers)");
12275 case NT_X86_XSTATE:
12276 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
12277 case NT_S390_HIGH_GPRS:
12278 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
12279 case NT_S390_TIMER:
12280 return _("NT_S390_TIMER (s390 timer register)");
12281 case NT_S390_TODCMP:
12282 return _("NT_S390_TODCMP (s390 TOD comparator register)");
12283 case NT_S390_TODPREG:
12284 return _("NT_S390_TODPREG (s390 TOD programmable register)");
12285 case NT_S390_CTRS:
12286 return _("NT_S390_CTRS (s390 control registers)");
12287 case NT_S390_PREFIX:
12288 return _("NT_S390_PREFIX (s390 prefix register)");
12289 case NT_ARM_VFP:
12290 return _("NT_ARM_VFP (arm VFP registers)");
12291 case NT_PSTATUS:
12292 return _("NT_PSTATUS (pstatus structure)");
12293 case NT_FPREGS:
12294 return _("NT_FPREGS (floating point registers)");
12295 case NT_PSINFO:
12296 return _("NT_PSINFO (psinfo structure)");
12297 case NT_LWPSTATUS:
12298 return _("NT_LWPSTATUS (lwpstatus_t structure)");
12299 case NT_LWPSINFO:
12300 return _("NT_LWPSINFO (lwpsinfo_t structure)");
12301 case NT_WIN32PSTATUS:
12302 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
12303 default:
12304 break;
12305 }
12306 else
12307 switch (e_type)
12308 {
12309 case NT_VERSION:
12310 return _("NT_VERSION (version)");
12311 case NT_ARCH:
12312 return _("NT_ARCH (architecture)");
12313 default:
12314 break;
12315 }
12316
12317 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12318 return buff;
12319 }
12320
12321 static const char *
12322 get_gnu_elf_note_type (unsigned e_type)
12323 {
12324 static char buff[64];
12325
12326 switch (e_type)
12327 {
12328 case NT_GNU_ABI_TAG:
12329 return _("NT_GNU_ABI_TAG (ABI version tag)");
12330 case NT_GNU_HWCAP:
12331 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
12332 case NT_GNU_BUILD_ID:
12333 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
12334 case NT_GNU_GOLD_VERSION:
12335 return _("NT_GNU_GOLD_VERSION (gold version)");
12336 default:
12337 break;
12338 }
12339
12340 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12341 return buff;
12342 }
12343
12344 static int
12345 print_gnu_note (Elf_Internal_Note *pnote)
12346 {
12347 switch (pnote->type)
12348 {
12349 case NT_GNU_BUILD_ID:
12350 {
12351 unsigned long i;
12352
12353 printf (_(" Build ID: "));
12354 for (i = 0; i < pnote->descsz; ++i)
12355 printf ("%02x", pnote->descdata[i] & 0xff);
12356 printf (_("\n"));
12357 }
12358 break;
12359
12360 case NT_GNU_ABI_TAG:
12361 {
12362 unsigned long os, major, minor, subminor;
12363 const char *osname;
12364
12365 os = byte_get ((unsigned char *) pnote->descdata, 4);
12366 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
12367 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
12368 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
12369
12370 switch (os)
12371 {
12372 case GNU_ABI_TAG_LINUX:
12373 osname = "Linux";
12374 break;
12375 case GNU_ABI_TAG_HURD:
12376 osname = "Hurd";
12377 break;
12378 case GNU_ABI_TAG_SOLARIS:
12379 osname = "Solaris";
12380 break;
12381 case GNU_ABI_TAG_FREEBSD:
12382 osname = "FreeBSD";
12383 break;
12384 case GNU_ABI_TAG_NETBSD:
12385 osname = "NetBSD";
12386 break;
12387 default:
12388 osname = "Unknown";
12389 break;
12390 }
12391
12392 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
12393 major, minor, subminor);
12394 }
12395 break;
12396 }
12397
12398 return 1;
12399 }
12400
12401 static const char *
12402 get_netbsd_elfcore_note_type (unsigned e_type)
12403 {
12404 static char buff[64];
12405
12406 if (e_type == NT_NETBSDCORE_PROCINFO)
12407 {
12408 /* NetBSD core "procinfo" structure. */
12409 return _("NetBSD procinfo structure");
12410 }
12411
12412 /* As of Jan 2002 there are no other machine-independent notes
12413 defined for NetBSD core files. If the note type is less
12414 than the start of the machine-dependent note types, we don't
12415 understand it. */
12416
12417 if (e_type < NT_NETBSDCORE_FIRSTMACH)
12418 {
12419 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12420 return buff;
12421 }
12422
12423 switch (elf_header.e_machine)
12424 {
12425 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
12426 and PT_GETFPREGS == mach+2. */
12427
12428 case EM_OLD_ALPHA:
12429 case EM_ALPHA:
12430 case EM_SPARC:
12431 case EM_SPARC32PLUS:
12432 case EM_SPARCV9:
12433 switch (e_type)
12434 {
12435 case NT_NETBSDCORE_FIRSTMACH + 0:
12436 return _("PT_GETREGS (reg structure)");
12437 case NT_NETBSDCORE_FIRSTMACH + 2:
12438 return _("PT_GETFPREGS (fpreg structure)");
12439 default:
12440 break;
12441 }
12442 break;
12443
12444 /* On all other arch's, PT_GETREGS == mach+1 and
12445 PT_GETFPREGS == mach+3. */
12446 default:
12447 switch (e_type)
12448 {
12449 case NT_NETBSDCORE_FIRSTMACH + 1:
12450 return _("PT_GETREGS (reg structure)");
12451 case NT_NETBSDCORE_FIRSTMACH + 3:
12452 return _("PT_GETFPREGS (fpreg structure)");
12453 default:
12454 break;
12455 }
12456 }
12457
12458 snprintf (buff, sizeof (buff), _("PT_FIRSTMACH+%d"),
12459 e_type - NT_NETBSDCORE_FIRSTMACH);
12460 return buff;
12461 }
12462
12463 static const char *
12464 get_stapsdt_note_type (unsigned e_type)
12465 {
12466 static char buff[64];
12467
12468 switch (e_type)
12469 {
12470 case NT_STAPSDT:
12471 return _("NT_STAPSDT (SystemTap probe descriptors)");
12472
12473 default:
12474 break;
12475 }
12476
12477 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12478 return buff;
12479 }
12480
12481 static int
12482 print_stapsdt_note (Elf_Internal_Note *pnote)
12483 {
12484 int addr_size = is_32bit_elf ? 4 : 8;
12485 char *data = pnote->descdata;
12486 char *data_end = pnote->descdata + pnote->descsz;
12487 bfd_vma pc, base_addr, semaphore;
12488 char *provider, *probe, *arg_fmt;
12489
12490 pc = byte_get ((unsigned char *) data, addr_size);
12491 data += addr_size;
12492 base_addr = byte_get ((unsigned char *) data, addr_size);
12493 data += addr_size;
12494 semaphore = byte_get ((unsigned char *) data, addr_size);
12495 data += addr_size;
12496
12497 provider = data;
12498 data += strlen (data) + 1;
12499 probe = data;
12500 data += strlen (data) + 1;
12501 arg_fmt = data;
12502 data += strlen (data) + 1;
12503
12504 printf (_(" Provider: %s\n"), provider);
12505 printf (_(" Name: %s\n"), probe);
12506 printf (_(" Location: "));
12507 print_vma (pc, FULL_HEX);
12508 printf (_(", Base: "));
12509 print_vma (base_addr, FULL_HEX);
12510 printf (_(", Semaphore: "));
12511 print_vma (semaphore, FULL_HEX);
12512 printf (_("\n"));
12513 printf (_(" Arguments: %s\n"), arg_fmt);
12514
12515 return data == data_end;
12516 }
12517
12518 static const char *
12519 get_ia64_vms_note_type (unsigned e_type)
12520 {
12521 static char buff[64];
12522
12523 switch (e_type)
12524 {
12525 case NT_VMS_MHD:
12526 return _("NT_VMS_MHD (module header)");
12527 case NT_VMS_LNM:
12528 return _("NT_VMS_LNM (language name)");
12529 case NT_VMS_SRC:
12530 return _("NT_VMS_SRC (source files)");
12531 case NT_VMS_TITLE:
12532 return _("NT_VMS_TITLE");
12533 case NT_VMS_EIDC:
12534 return _("NT_VMS_EIDC (consistency check)");
12535 case NT_VMS_FPMODE:
12536 return _("NT_VMS_FPMODE (FP mode)");
12537 case NT_VMS_LINKTIME:
12538 return _("NT_VMS_LINKTIME");
12539 case NT_VMS_IMGNAM:
12540 return _("NT_VMS_IMGNAM (image name)");
12541 case NT_VMS_IMGID:
12542 return _("NT_VMS_IMGID (image id)");
12543 case NT_VMS_LINKID:
12544 return _("NT_VMS_LINKID (link id)");
12545 case NT_VMS_IMGBID:
12546 return _("NT_VMS_IMGBID (build id)");
12547 case NT_VMS_GSTNAM:
12548 return _("NT_VMS_GSTNAM (sym table name)");
12549 case NT_VMS_ORIG_DYN:
12550 return _("NT_VMS_ORIG_DYN");
12551 case NT_VMS_PATCHTIME:
12552 return _("NT_VMS_PATCHTIME");
12553 default:
12554 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12555 return buff;
12556 }
12557 }
12558
12559 static int
12560 print_ia64_vms_note (Elf_Internal_Note * pnote)
12561 {
12562 switch (pnote->type)
12563 {
12564 case NT_VMS_MHD:
12565 if (pnote->descsz > 36)
12566 {
12567 size_t l = strlen (pnote->descdata + 34);
12568 printf (_(" Creation date : %.17s\n"), pnote->descdata);
12569 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
12570 printf (_(" Module name : %s\n"), pnote->descdata + 34);
12571 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
12572 }
12573 else
12574 printf (_(" Invalid size\n"));
12575 break;
12576 case NT_VMS_LNM:
12577 printf (_(" Language: %s\n"), pnote->descdata);
12578 break;
12579 #ifdef BFD64
12580 case NT_VMS_FPMODE:
12581 printf (_(" FP mode: 0x%016" BFD_VMA_FMT "x\n"),
12582 (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
12583 break;
12584 case NT_VMS_LINKTIME:
12585 printf (_(" Link time: "));
12586 print_vms_time
12587 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
12588 printf ("\n");
12589 break;
12590 case NT_VMS_PATCHTIME:
12591 printf (_(" Patch time: "));
12592 print_vms_time
12593 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
12594 printf ("\n");
12595 break;
12596 case NT_VMS_ORIG_DYN:
12597 printf (_(" Major id: %u, minor id: %u\n"),
12598 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
12599 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
12600 printf (_(" Manip date : "));
12601 print_vms_time
12602 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
12603 printf (_("\n"
12604 " Link flags : 0x%016" BFD_VMA_FMT "x\n"),
12605 (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
12606 printf (_(" Header flags: 0x%08x\n"),
12607 (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
12608 printf (_(" Image id : %s\n"), pnote->descdata + 32);
12609 break;
12610 #endif
12611 case NT_VMS_IMGNAM:
12612 printf (_(" Image name: %s\n"), pnote->descdata);
12613 break;
12614 case NT_VMS_GSTNAM:
12615 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
12616 break;
12617 case NT_VMS_IMGID:
12618 printf (_(" Image id: %s\n"), pnote->descdata);
12619 break;
12620 case NT_VMS_LINKID:
12621 printf (_(" Linker id: %s\n"), pnote->descdata);
12622 break;
12623 default:
12624 break;
12625 }
12626 return 1;
12627 }
12628
12629 /* Note that by the ELF standard, the name field is already null byte
12630 terminated, and namesz includes the terminating null byte.
12631 I.E. the value of namesz for the name "FSF" is 4.
12632
12633 If the value of namesz is zero, there is no name present. */
12634 static int
12635 process_note (Elf_Internal_Note * pnote)
12636 {
12637 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
12638 const char * nt;
12639
12640 if (pnote->namesz == 0)
12641 /* If there is no note name, then use the default set of
12642 note type strings. */
12643 nt = get_note_type (pnote->type);
12644
12645 else if (const_strneq (pnote->namedata, "GNU"))
12646 /* GNU-specific object file notes. */
12647 nt = get_gnu_elf_note_type (pnote->type);
12648
12649 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
12650 /* NetBSD-specific core file notes. */
12651 nt = get_netbsd_elfcore_note_type (pnote->type);
12652
12653 else if (strneq (pnote->namedata, "SPU/", 4))
12654 {
12655 /* SPU-specific core file notes. */
12656 nt = pnote->namedata + 4;
12657 name = "SPU";
12658 }
12659
12660 else if (const_strneq (pnote->namedata, "IPF/VMS"))
12661 /* VMS/ia64-specific file notes. */
12662 nt = get_ia64_vms_note_type (pnote->type);
12663
12664 else if (const_strneq (pnote->namedata, "stapsdt"))
12665 nt = get_stapsdt_note_type (pnote->type);
12666
12667 else
12668 /* Don't recognize this note name; just use the default set of
12669 note type strings. */
12670 nt = get_note_type (pnote->type);
12671
12672 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
12673
12674 if (const_strneq (pnote->namedata, "IPF/VMS"))
12675 return print_ia64_vms_note (pnote);
12676 else if (const_strneq (pnote->namedata, "GNU"))
12677 return print_gnu_note (pnote);
12678 else if (const_strneq (pnote->namedata, "stapsdt"))
12679 return print_stapsdt_note (pnote);
12680 else
12681 return 1;
12682 }
12683
12684
12685 static int
12686 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
12687 {
12688 Elf_External_Note * pnotes;
12689 Elf_External_Note * external;
12690 int res = 1;
12691
12692 if (length <= 0)
12693 return 0;
12694
12695 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
12696 _("notes"));
12697 if (pnotes == NULL)
12698 return 0;
12699
12700 external = pnotes;
12701
12702 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
12703 (unsigned long) offset, (unsigned long) length);
12704 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
12705
12706 while (external < (Elf_External_Note *) ((char *) pnotes + length))
12707 {
12708 Elf_External_Note * next;
12709 Elf_Internal_Note inote;
12710 char * temp = NULL;
12711
12712 if (!is_ia64_vms ())
12713 {
12714 inote.type = BYTE_GET (external->type);
12715 inote.namesz = BYTE_GET (external->namesz);
12716 inote.namedata = external->name;
12717 inote.descsz = BYTE_GET (external->descsz);
12718 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
12719 inote.descpos = offset + (inote.descdata - (char *) pnotes);
12720
12721 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
12722 }
12723 else
12724 {
12725 Elf64_External_VMS_Note *vms_external;
12726
12727 vms_external = (Elf64_External_VMS_Note *)external;
12728 inote.type = BYTE_GET (vms_external->type);
12729 inote.namesz = BYTE_GET (vms_external->namesz);
12730 inote.namedata = vms_external->name;
12731 inote.descsz = BYTE_GET (vms_external->descsz);
12732 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
12733 inote.descpos = offset + (inote.descdata - (char *) pnotes);
12734
12735 next = (Elf_External_Note *)
12736 (inote.descdata + align_power (inote.descsz, 3));
12737 }
12738
12739 if ( ((char *) next > ((char *) pnotes) + length)
12740 || ((char *) next < (char *) pnotes))
12741 {
12742 warn (_("corrupt note found at offset %lx into core notes\n"),
12743 (unsigned long) ((char *) external - (char *) pnotes));
12744 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
12745 inote.type, inote.namesz, inote.descsz);
12746 break;
12747 }
12748
12749 external = next;
12750
12751 /* Prevent out-of-bounds indexing. */
12752 if (inote.namedata + inote.namesz >= (char *) pnotes + length
12753 || inote.namedata + inote.namesz < inote.namedata)
12754 {
12755 warn (_("corrupt note found at offset %lx into core notes\n"),
12756 (unsigned long) ((char *) external - (char *) pnotes));
12757 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
12758 inote.type, inote.namesz, inote.descsz);
12759 break;
12760 }
12761
12762 /* Verify that name is null terminated. It appears that at least
12763 one version of Linux (RedHat 6.0) generates corefiles that don't
12764 comply with the ELF spec by failing to include the null byte in
12765 namesz. */
12766 if (inote.namedata[inote.namesz] != '\0')
12767 {
12768 temp = (char *) malloc (inote.namesz + 1);
12769
12770 if (temp == NULL)
12771 {
12772 error (_("Out of memory\n"));
12773 res = 0;
12774 break;
12775 }
12776
12777 strncpy (temp, inote.namedata, inote.namesz);
12778 temp[inote.namesz] = 0;
12779
12780 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
12781 inote.namedata = temp;
12782 }
12783
12784 res &= process_note (& inote);
12785
12786 if (temp != NULL)
12787 {
12788 free (temp);
12789 temp = NULL;
12790 }
12791 }
12792
12793 free (pnotes);
12794
12795 return res;
12796 }
12797
12798 static int
12799 process_corefile_note_segments (FILE * file)
12800 {
12801 Elf_Internal_Phdr * segment;
12802 unsigned int i;
12803 int res = 1;
12804
12805 if (! get_program_headers (file))
12806 return 0;
12807
12808 for (i = 0, segment = program_headers;
12809 i < elf_header.e_phnum;
12810 i++, segment++)
12811 {
12812 if (segment->p_type == PT_NOTE)
12813 res &= process_corefile_note_segment (file,
12814 (bfd_vma) segment->p_offset,
12815 (bfd_vma) segment->p_filesz);
12816 }
12817
12818 return res;
12819 }
12820
12821 static int
12822 process_note_sections (FILE * file)
12823 {
12824 Elf_Internal_Shdr * section;
12825 unsigned long i;
12826 int res = 1;
12827
12828 for (i = 0, section = section_headers;
12829 i < elf_header.e_shnum;
12830 i++, section++)
12831 if (section->sh_type == SHT_NOTE)
12832 res &= process_corefile_note_segment (file,
12833 (bfd_vma) section->sh_offset,
12834 (bfd_vma) section->sh_size);
12835
12836 return res;
12837 }
12838
12839 static int
12840 process_notes (FILE * file)
12841 {
12842 /* If we have not been asked to display the notes then do nothing. */
12843 if (! do_notes)
12844 return 1;
12845
12846 if (elf_header.e_type != ET_CORE)
12847 return process_note_sections (file);
12848
12849 /* No program headers means no NOTE segment. */
12850 if (elf_header.e_phnum > 0)
12851 return process_corefile_note_segments (file);
12852
12853 printf (_("No note segments present in the core file.\n"));
12854 return 1;
12855 }
12856
12857 static int
12858 process_arch_specific (FILE * file)
12859 {
12860 if (! do_arch)
12861 return 1;
12862
12863 switch (elf_header.e_machine)
12864 {
12865 case EM_ARM:
12866 return process_arm_specific (file);
12867 case EM_MIPS:
12868 case EM_MIPS_RS3_LE:
12869 return process_mips_specific (file);
12870 break;
12871 case EM_PPC:
12872 return process_power_specific (file);
12873 break;
12874 case EM_TI_C6000:
12875 return process_tic6x_specific (file);
12876 break;
12877 default:
12878 break;
12879 }
12880 return 1;
12881 }
12882
12883 static int
12884 get_file_header (FILE * file)
12885 {
12886 /* Read in the identity array. */
12887 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
12888 return 0;
12889
12890 /* Determine how to read the rest of the header. */
12891 switch (elf_header.e_ident[EI_DATA])
12892 {
12893 default: /* fall through */
12894 case ELFDATANONE: /* fall through */
12895 case ELFDATA2LSB:
12896 byte_get = byte_get_little_endian;
12897 byte_put = byte_put_little_endian;
12898 break;
12899 case ELFDATA2MSB:
12900 byte_get = byte_get_big_endian;
12901 byte_put = byte_put_big_endian;
12902 break;
12903 }
12904
12905 /* For now we only support 32 bit and 64 bit ELF files. */
12906 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
12907
12908 /* Read in the rest of the header. */
12909 if (is_32bit_elf)
12910 {
12911 Elf32_External_Ehdr ehdr32;
12912
12913 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
12914 return 0;
12915
12916 elf_header.e_type = BYTE_GET (ehdr32.e_type);
12917 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
12918 elf_header.e_version = BYTE_GET (ehdr32.e_version);
12919 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
12920 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
12921 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
12922 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
12923 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
12924 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
12925 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
12926 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
12927 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
12928 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
12929 }
12930 else
12931 {
12932 Elf64_External_Ehdr ehdr64;
12933
12934 /* If we have been compiled with sizeof (bfd_vma) == 4, then
12935 we will not be able to cope with the 64bit data found in
12936 64 ELF files. Detect this now and abort before we start
12937 overwriting things. */
12938 if (sizeof (bfd_vma) < 8)
12939 {
12940 error (_("This instance of readelf has been built without support for a\n\
12941 64 bit data type and so it cannot read 64 bit ELF files.\n"));
12942 return 0;
12943 }
12944
12945 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
12946 return 0;
12947
12948 elf_header.e_type = BYTE_GET (ehdr64.e_type);
12949 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
12950 elf_header.e_version = BYTE_GET (ehdr64.e_version);
12951 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
12952 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
12953 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
12954 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
12955 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
12956 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
12957 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
12958 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
12959 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
12960 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
12961 }
12962
12963 if (elf_header.e_shoff)
12964 {
12965 /* There may be some extensions in the first section header. Don't
12966 bomb if we can't read it. */
12967 if (is_32bit_elf)
12968 get_32bit_section_headers (file, 1);
12969 else
12970 get_64bit_section_headers (file, 1);
12971 }
12972
12973 return 1;
12974 }
12975
12976 /* Process one ELF object file according to the command line options.
12977 This file may actually be stored in an archive. The file is
12978 positioned at the start of the ELF object. */
12979
12980 static int
12981 process_object (char * file_name, FILE * file)
12982 {
12983 unsigned int i;
12984
12985 if (! get_file_header (file))
12986 {
12987 error (_("%s: Failed to read file header\n"), file_name);
12988 return 1;
12989 }
12990
12991 /* Initialise per file variables. */
12992 for (i = ARRAY_SIZE (version_info); i--;)
12993 version_info[i] = 0;
12994
12995 for (i = ARRAY_SIZE (dynamic_info); i--;)
12996 dynamic_info[i] = 0;
12997 dynamic_info_DT_GNU_HASH = 0;
12998
12999 /* Process the file. */
13000 if (show_name)
13001 printf (_("\nFile: %s\n"), file_name);
13002
13003 /* Initialise the dump_sects array from the cmdline_dump_sects array.
13004 Note we do this even if cmdline_dump_sects is empty because we
13005 must make sure that the dump_sets array is zeroed out before each
13006 object file is processed. */
13007 if (num_dump_sects > num_cmdline_dump_sects)
13008 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
13009
13010 if (num_cmdline_dump_sects > 0)
13011 {
13012 if (num_dump_sects == 0)
13013 /* A sneaky way of allocating the dump_sects array. */
13014 request_dump_bynumber (num_cmdline_dump_sects, 0);
13015
13016 assert (num_dump_sects >= num_cmdline_dump_sects);
13017 memcpy (dump_sects, cmdline_dump_sects,
13018 num_cmdline_dump_sects * sizeof (* dump_sects));
13019 }
13020
13021 if (! process_file_header ())
13022 return 1;
13023
13024 if (! process_section_headers (file))
13025 {
13026 /* Without loaded section headers we cannot process lots of
13027 things. */
13028 do_unwind = do_version = do_dump = do_arch = 0;
13029
13030 if (! do_using_dynamic)
13031 do_syms = do_dyn_syms = do_reloc = 0;
13032 }
13033
13034 if (! process_section_groups (file))
13035 {
13036 /* Without loaded section groups we cannot process unwind. */
13037 do_unwind = 0;
13038 }
13039
13040 if (process_program_headers (file))
13041 process_dynamic_section (file);
13042
13043 process_relocs (file);
13044
13045 process_unwind (file);
13046
13047 process_symbol_table (file);
13048
13049 process_syminfo (file);
13050
13051 process_version_sections (file);
13052
13053 process_section_contents (file);
13054
13055 process_notes (file);
13056
13057 process_gnu_liblist (file);
13058
13059 process_arch_specific (file);
13060
13061 if (program_headers)
13062 {
13063 free (program_headers);
13064 program_headers = NULL;
13065 }
13066
13067 if (section_headers)
13068 {
13069 free (section_headers);
13070 section_headers = NULL;
13071 }
13072
13073 if (string_table)
13074 {
13075 free (string_table);
13076 string_table = NULL;
13077 string_table_length = 0;
13078 }
13079
13080 if (dynamic_strings)
13081 {
13082 free (dynamic_strings);
13083 dynamic_strings = NULL;
13084 dynamic_strings_length = 0;
13085 }
13086
13087 if (dynamic_symbols)
13088 {
13089 free (dynamic_symbols);
13090 dynamic_symbols = NULL;
13091 num_dynamic_syms = 0;
13092 }
13093
13094 if (dynamic_syminfo)
13095 {
13096 free (dynamic_syminfo);
13097 dynamic_syminfo = NULL;
13098 }
13099
13100 if (dynamic_section)
13101 {
13102 free (dynamic_section);
13103 dynamic_section = NULL;
13104 }
13105
13106 if (section_headers_groups)
13107 {
13108 free (section_headers_groups);
13109 section_headers_groups = NULL;
13110 }
13111
13112 if (section_groups)
13113 {
13114 struct group_list * g;
13115 struct group_list * next;
13116
13117 for (i = 0; i < group_count; i++)
13118 {
13119 for (g = section_groups [i].root; g != NULL; g = next)
13120 {
13121 next = g->next;
13122 free (g);
13123 }
13124 }
13125
13126 free (section_groups);
13127 section_groups = NULL;
13128 }
13129
13130 free_debug_memory ();
13131
13132 return 0;
13133 }
13134
13135 /* Process an ELF archive.
13136 On entry the file is positioned just after the ARMAG string. */
13137
13138 static int
13139 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
13140 {
13141 struct archive_info arch;
13142 struct archive_info nested_arch;
13143 size_t got;
13144 int ret;
13145
13146 show_name = 1;
13147
13148 /* The ARCH structure is used to hold information about this archive. */
13149 arch.file_name = NULL;
13150 arch.file = NULL;
13151 arch.index_array = NULL;
13152 arch.sym_table = NULL;
13153 arch.longnames = NULL;
13154
13155 /* The NESTED_ARCH structure is used as a single-item cache of information
13156 about a nested archive (when members of a thin archive reside within
13157 another regular archive file). */
13158 nested_arch.file_name = NULL;
13159 nested_arch.file = NULL;
13160 nested_arch.index_array = NULL;
13161 nested_arch.sym_table = NULL;
13162 nested_arch.longnames = NULL;
13163
13164 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
13165 {
13166 ret = 1;
13167 goto out;
13168 }
13169
13170 if (do_archive_index)
13171 {
13172 if (arch.sym_table == NULL)
13173 error (_("%s: unable to dump the index as none was found\n"), file_name);
13174 else
13175 {
13176 unsigned int i, l;
13177 unsigned long current_pos;
13178
13179 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
13180 file_name, arch.index_num, arch.sym_size);
13181 current_pos = ftell (file);
13182
13183 for (i = l = 0; i < arch.index_num; i++)
13184 {
13185 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
13186 {
13187 char * member_name;
13188
13189 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
13190
13191 if (member_name != NULL)
13192 {
13193 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
13194
13195 if (qualified_name != NULL)
13196 {
13197 printf (_("Binary %s contains:\n"), qualified_name);
13198 free (qualified_name);
13199 }
13200 }
13201 }
13202
13203 if (l >= arch.sym_size)
13204 {
13205 error (_("%s: end of the symbol table reached before the end of the index\n"),
13206 file_name);
13207 break;
13208 }
13209 printf ("\t%s\n", arch.sym_table + l);
13210 l += strlen (arch.sym_table + l) + 1;
13211 }
13212
13213 if (l & 01)
13214 ++l;
13215 if (l < arch.sym_size)
13216 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
13217 file_name);
13218
13219 if (fseek (file, current_pos, SEEK_SET) != 0)
13220 {
13221 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
13222 ret = 1;
13223 goto out;
13224 }
13225 }
13226
13227 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
13228 && !do_segments && !do_header && !do_dump && !do_version
13229 && !do_histogram && !do_debugging && !do_arch && !do_notes
13230 && !do_section_groups && !do_dyn_syms)
13231 {
13232 ret = 0; /* Archive index only. */
13233 goto out;
13234 }
13235 }
13236
13237 ret = 0;
13238
13239 while (1)
13240 {
13241 char * name;
13242 size_t namelen;
13243 char * qualified_name;
13244
13245 /* Read the next archive header. */
13246 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
13247 {
13248 error (_("%s: failed to seek to next archive header\n"), file_name);
13249 return 1;
13250 }
13251 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
13252 if (got != sizeof arch.arhdr)
13253 {
13254 if (got == 0)
13255 break;
13256 error (_("%s: failed to read archive header\n"), file_name);
13257 ret = 1;
13258 break;
13259 }
13260 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
13261 {
13262 error (_("%s: did not find a valid archive header\n"), arch.file_name);
13263 ret = 1;
13264 break;
13265 }
13266
13267 arch.next_arhdr_offset += sizeof arch.arhdr;
13268
13269 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
13270 if (archive_file_size & 01)
13271 ++archive_file_size;
13272
13273 name = get_archive_member_name (&arch, &nested_arch);
13274 if (name == NULL)
13275 {
13276 error (_("%s: bad archive file name\n"), file_name);
13277 ret = 1;
13278 break;
13279 }
13280 namelen = strlen (name);
13281
13282 qualified_name = make_qualified_name (&arch, &nested_arch, name);
13283 if (qualified_name == NULL)
13284 {
13285 error (_("%s: bad archive file name\n"), file_name);
13286 ret = 1;
13287 break;
13288 }
13289
13290 if (is_thin_archive && arch.nested_member_origin == 0)
13291 {
13292 /* This is a proxy for an external member of a thin archive. */
13293 FILE * member_file;
13294 char * member_file_name = adjust_relative_path (file_name, name, namelen);
13295 if (member_file_name == NULL)
13296 {
13297 ret = 1;
13298 break;
13299 }
13300
13301 member_file = fopen (member_file_name, "rb");
13302 if (member_file == NULL)
13303 {
13304 error (_("Input file '%s' is not readable.\n"), member_file_name);
13305 free (member_file_name);
13306 ret = 1;
13307 break;
13308 }
13309
13310 archive_file_offset = arch.nested_member_origin;
13311
13312 ret |= process_object (qualified_name, member_file);
13313
13314 fclose (member_file);
13315 free (member_file_name);
13316 }
13317 else if (is_thin_archive)
13318 {
13319 /* This is a proxy for a member of a nested archive. */
13320 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
13321
13322 /* The nested archive file will have been opened and setup by
13323 get_archive_member_name. */
13324 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
13325 {
13326 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
13327 ret = 1;
13328 break;
13329 }
13330
13331 ret |= process_object (qualified_name, nested_arch.file);
13332 }
13333 else
13334 {
13335 archive_file_offset = arch.next_arhdr_offset;
13336 arch.next_arhdr_offset += archive_file_size;
13337
13338 ret |= process_object (qualified_name, file);
13339 }
13340
13341 if (dump_sects != NULL)
13342 {
13343 free (dump_sects);
13344 dump_sects = NULL;
13345 num_dump_sects = 0;
13346 }
13347
13348 free (qualified_name);
13349 }
13350
13351 out:
13352 if (nested_arch.file != NULL)
13353 fclose (nested_arch.file);
13354 release_archive (&nested_arch);
13355 release_archive (&arch);
13356
13357 return ret;
13358 }
13359
13360 static int
13361 process_file (char * file_name)
13362 {
13363 FILE * file;
13364 struct stat statbuf;
13365 char armag[SARMAG];
13366 int ret;
13367
13368 if (stat (file_name, &statbuf) < 0)
13369 {
13370 if (errno == ENOENT)
13371 error (_("'%s': No such file\n"), file_name);
13372 else
13373 error (_("Could not locate '%s'. System error message: %s\n"),
13374 file_name, strerror (errno));
13375 return 1;
13376 }
13377
13378 if (! S_ISREG (statbuf.st_mode))
13379 {
13380 error (_("'%s' is not an ordinary file\n"), file_name);
13381 return 1;
13382 }
13383
13384 file = fopen (file_name, "rb");
13385 if (file == NULL)
13386 {
13387 error (_("Input file '%s' is not readable.\n"), file_name);
13388 return 1;
13389 }
13390
13391 if (fread (armag, SARMAG, 1, file) != 1)
13392 {
13393 error (_("%s: Failed to read file's magic number\n"), file_name);
13394 fclose (file);
13395 return 1;
13396 }
13397
13398 if (memcmp (armag, ARMAG, SARMAG) == 0)
13399 ret = process_archive (file_name, file, FALSE);
13400 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
13401 ret = process_archive (file_name, file, TRUE);
13402 else
13403 {
13404 if (do_archive_index)
13405 error (_("File %s is not an archive so its index cannot be displayed.\n"),
13406 file_name);
13407
13408 rewind (file);
13409 archive_file_size = archive_file_offset = 0;
13410 ret = process_object (file_name, file);
13411 }
13412
13413 fclose (file);
13414
13415 return ret;
13416 }
13417
13418 #ifdef SUPPORT_DISASSEMBLY
13419 /* Needed by the i386 disassembler. For extra credit, someone could
13420 fix this so that we insert symbolic addresses here, esp for GOT/PLT
13421 symbols. */
13422
13423 void
13424 print_address (unsigned int addr, FILE * outfile)
13425 {
13426 fprintf (outfile,"0x%8.8x", addr);
13427 }
13428
13429 /* Needed by the i386 disassembler. */
13430 void
13431 db_task_printsym (unsigned int addr)
13432 {
13433 print_address (addr, stderr);
13434 }
13435 #endif
13436
13437 int
13438 main (int argc, char ** argv)
13439 {
13440 int err;
13441
13442 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
13443 setlocale (LC_MESSAGES, "");
13444 #endif
13445 #if defined (HAVE_SETLOCALE)
13446 setlocale (LC_CTYPE, "");
13447 #endif
13448 bindtextdomain (PACKAGE, LOCALEDIR);
13449 textdomain (PACKAGE);
13450
13451 expandargv (&argc, &argv);
13452
13453 parse_args (argc, argv);
13454
13455 if (num_dump_sects > 0)
13456 {
13457 /* Make a copy of the dump_sects array. */
13458 cmdline_dump_sects = (dump_type *)
13459 malloc (num_dump_sects * sizeof (* dump_sects));
13460 if (cmdline_dump_sects == NULL)
13461 error (_("Out of memory allocating dump request table.\n"));
13462 else
13463 {
13464 memcpy (cmdline_dump_sects, dump_sects,
13465 num_dump_sects * sizeof (* dump_sects));
13466 num_cmdline_dump_sects = num_dump_sects;
13467 }
13468 }
13469
13470 if (optind < (argc - 1))
13471 show_name = 1;
13472
13473 err = 0;
13474 while (optind < argc)
13475 err |= process_file (argv[optind++]);
13476
13477 if (dump_sects != NULL)
13478 free (dump_sects);
13479 if (cmdline_dump_sects != NULL)
13480 free (cmdline_dump_sects);
13481
13482 return err;
13483 }
git-cvsimport of binutils cvsroot