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