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