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