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