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